LLVMFuzzerTestOneInput: 143| 22.2k|{ 144| 22.2k| const std::string_view input{reinterpret_cast(Data), Size}; 145| | 146| | // Raw bytes: the batch split, the syntax check, and the envelope read. 147| 22.2k| { 148| 22.2k| const auto buf = exact_buffer(input); 149| 22.2k| drive({buf.data(), buf.size()}); 150| 22.2k| } 151| | 152| 22.2k| if (Size < 1) { ------------------ | Branch (152:8): [True: 0, False: 22.2k] ------------------ 153| 0| return 0; 154| 0| } 155| | 156| | // Wrapped: the input becomes the params of an envelope that is otherwise well formed, so the 157| | // params reader is reached even when the fuzzer has not yet learned the envelope's shape. The 158| | // first byte picks the method, since which one is registered decides what the params must parse 159| | // as, and a params reader is only interesting once it has a destination type. 160| | // "" is the root method, which reads the whole registered object in one document -- every nested 161| | // struct, container, optional and variant at once, and the deepest reader nesting on offer. 162| 22.2k| static constexpr std::string_view methods[] = { 163| 22.2k| "", "value", "name", "position", "position/x", "inner", "series", "table", "maybe", "measure", 164| 22.2k| "doubled", "greet", "midpoint", "total", "reset", "counter", "scale", "bump", "shift", "absent"}; 165| 22.2k| const std::string_view method = methods[Data[0] % (sizeof(methods) / sizeof(methods[0]))]; 166| 22.2k| const std::string_view params = input.substr(1); 167| | 168| 22.2k| { 169| 22.2k| std::string request; 170| 22.2k| request += R"({"jsonrpc":"2.0","method":")"; 171| 22.2k| request += method; 172| 22.2k| request += R"(","params":)"; 173| 22.2k| request += params; 174| 22.2k| request += R"(,"id":1})"; 175| | 176| 22.2k| const auto buf = exact_buffer(request); 177| 22.2k| drive({buf.data(), buf.size()}); 178| 22.2k| } 179| | 180| | // The same envelope inside a batch, which takes a different path: the array is split into raw 181| | // views first and each element is read on its own. 182| 22.2k| { 183| 22.2k| std::string request; 184| 22.2k| request += R"([{"jsonrpc":"2.0","method":")"; 185| 22.2k| request += method; 186| 22.2k| request += R"(","params":)"; 187| 22.2k| request += params; 188| 22.2k| request += R"(,"id":1},{"jsonrpc":"2.0","method":")"; 189| 22.2k| request += method; 190| 22.2k| request += R"("}])"; // second element is a notification, so it takes the no-response path 191| | 192| 22.2k| const auto buf = exact_buffer(request); 193| 22.2k| drive({buf.data(), buf.size()}); 194| 22.2k| } 195| | 196| 22.2k| return 0; 197| 22.2k|} jsonrpc_registry.cpp:_ZN12_GLOBAL__N_112exact_bufferENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 111| 129k| { 112| 129k| std::vector buf(bytes.size()); 113| 129k| if (!bytes.empty()) { ------------------ | Branch (113:11): [True: 129k, False: 0] ------------------ 114| 129k| std::memcpy(buf.data(), bytes.data(), bytes.size()); 115| 129k| } 116| 129k| return buf; 117| 129k| } jsonrpc_registry.cpp:_ZN12_GLOBAL__N_15driveENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 120| 66.7k| { 121| 66.7k| glz::registry registry; 122| 66.7k| fuzz_api api{}; 123| 66.7k| jsonrpc_fuzz::member_api members{}; 124| | // members first, so the last registration -- and therefore the root endpoint -- is the wider 125| | // of the two objects. Root reads the whole object in one document, so it should be the one 126| | // with the nested struct, containers, optional and variant in it. 127| 66.7k| registry.on(members); 128| 66.7k| registry.on(api); 129| | 130| 66.7k| const auto response = registry.call(request); 131| 66.7k| if (!response.empty()) { ------------------ | Branch (131:11): [True: 63.0k, False: 3.64k] ------------------ 132| | // The response is JSON the registry itself produced, so reading it back checks that what 133| | // goes out is well formed even when what came in was not. 134| 63.0k| const auto buf = exact_buffer(response); 135| 63.0k| glz::generic parsed{}; 136| 63.0k| [[maybe_unused]] auto ec = 137| 63.0k| glz::read(parsed, std::string_view{buf.data(), buf.size()}); 138| 63.0k| } 139| 66.7k| } _ZNK12jsonrpc_fuzz8fuzz_api7doubledMUliE_clEi: 66| 916| std::function doubled = [](int32_t v) { return int32_t(uint32_t(v) * 2u); }; _ZNK12jsonrpc_fuzz8fuzz_api5greetMUlRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE_clESA_: 67| 2.46k| std::function greet = [](const std::string& who) { return "hi " + who; }; _ZNK12jsonrpc_fuzz8fuzz_api8midpointMUlRKNS_5pointEE_clES4_: 68| 762| std::function midpoint = [](const point& p) -> point { return {p.x / 2, p.y / 2}; }; _ZNK12jsonrpc_fuzz8fuzz_api5totalMUlRNSt3__16vectorIdNS2_9allocatorIdEEEEE_clES7_: 69| 4.25k| std::function&)> total = [](std::vector& v) { 70| 4.25k| double sum{}; 71| 150k| for (auto d : v) sum += d; ------------------ | Branch (71:22): [True: 150k, False: 4.25k] ------------------ 72| 4.25k| return sum; 73| 4.25k| }; _ZNK12jsonrpc_fuzz8fuzz_api5resetMUlvE_clEv: 74| 550| std::function reset = [] {}; _ZN12jsonrpc_fuzz10member_api5scaleEi: 89| 645| { 90| 645| counter = int32_t(uint32_t(counter) + uint32_t(v)); 91| 645| return int32_t(uint32_t(v) * 3u); 92| 645| } _ZN12jsonrpc_fuzz10member_api4bumpEv: 93| 316| void bump() { counter = int32_t(uint32_t(counter) + 1u); } _ZN12jsonrpc_fuzz10member_api5shiftERKNS_5pointE: 94| 602| point shift(const point& p) { return {p.x + 1, p.y + 1}; } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__16vectorIiNS1_9allocatorIiEEEEEEbOT_: 284| 175| { 285| 175|#ifdef __cpp_lib_ranges 286| 175| return std::ranges::empty(rng); 287| |#else 288| | // in lieu of std::ranges::empty 289| | if constexpr (requires() { 290| | { rng.empty() } -> std::convertible_to; 291| | }) { 292| | return rng.empty(); 293| | } 294| | else if constexpr (requires() { 295| | { rng.size() } -> std::same_as; 296| | }) { 297| | return rng.size() == std::size_t{0}; 298| | } 299| | else { 300| | return std::cbegin(rng) == std::cend(rng); 301| | } 302| |#endif 303| 175| } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEEEbOT_: 284| 103| { 285| 103|#ifdef __cpp_lib_ranges 286| 103| return std::ranges::empty(rng); 287| |#else 288| | // in lieu of std::ranges::empty 289| | if constexpr (requires() { 290| | { rng.empty() } -> std::convertible_to; 291| | }) { 292| | return rng.empty(); 293| | } 294| | else if constexpr (requires() { 295| | { rng.size() } -> std::same_as; 296| | }) { 297| | return rng.size() == std::size_t{0}; 298| | } 299| | else { 300| | return std::cbegin(rng) == std::cend(rng); 301| | } 302| |#endif 303| 103| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2Ev: 566| 501k| ordered_small_map() = default; _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9free_dataEv: 266| 1.31M| { 267| 1.31M| destroy_all(); 268| 1.31M| ::operator delete(data_); 269| 1.31M| data_ = nullptr; 270| 1.31M| size_ = 0; 271| 1.31M| capacity_ = 0; 272| 1.31M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11destroy_allEv: 259| 1.82M| { 260| 3.30M| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (260:31): [True: 1.48M, False: 1.82M] ------------------ 261| 1.48M| std::destroy_at(data_ + i); 262| 1.48M| } 263| 1.82M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10free_indexEv: 308| 1.31M| { 309| 1.31M| std::free(index_); 310| 1.31M| index_ = nullptr; 311| 1.31M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2EOS4_: 610| 817k| : data_(other.data_), size_(other.size_), capacity_(other.capacity_), index_(other.index_) 611| 817k| { 612| 817k| other.data_ = nullptr; 613| 817k| other.size_ = 0; 614| 817k| other.capacity_ = 0; 615| 817k| other.index_ = nullptr; 616| 817k| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEED2Ev: 569| 1.31M| { 570| 1.31M| free_data(); 571| 1.31M| free_index(); 572| 1.31M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 932| 1.48M| { 933| 1.48M| return subscript_or_insert(key, [&] { emplace_back_impl(key, mapped_type{}); }); 934| 1.48M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19subscript_or_insertINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEZNS4_ixERKSC_EUlvE_EERS3_RKT_OT0_: 491| 1.48M| { 492| 1.48M| if (size_ <= linear_search_threshold) { ------------------ | Branch (492:14): [True: 1.48M, False: 150] ------------------ 493| 1.48M| auto it = linear_find(key); 494| 1.48M| if (it != end()) return it->second; ------------------ | Branch (494:17): [True: 0, False: 1.48M] ------------------ 495| 1.48M| append_fn(); 496| 1.48M| return data_[size_ - 1].second; 497| 1.48M| } 498| | 499| 150| const uint32_t h = hash_key(key); 500| 150| if (try_bloom_insert(h, append_fn)) { ------------------ | Branch (500:14): [True: 100, False: 50] ------------------ 501| 100| return data_[size_ - 1].second; 502| 100| } 503| | 504| 50| auto [it, pos, _] = index_find_or_pos(key, h); 505| 50| if (it != end()) return it->second; ------------------ | Branch (505:14): [True: 0, False: 50] ------------------ 506| | 507| 50| append_fn(); 508| 50| bloom_set(h); 509| 50| if (index_size() > 0) { ------------------ | Branch (509:14): [True: 50, False: 0] ------------------ 510| 50| const uint32_t n = index_->size; 511| 50| ensure_index_capacity(static_cast(n) + 1); 512| 50| auto* entries = index_entries(); 513| 50| if (pos < n) { ------------------ | Branch (513:17): [True: 0, False: 50] ------------------ 514| 0| std::memmove(entries + pos + 1, entries + pos, (n - pos) * sizeof(hash_index_entry)); 515| 0| } 516| 50| entries[pos] = {h, size_ - 1}; 517| 50| index_->size = size_; 518| 50| } 519| 50| return data_[size_ - 1].second; 520| 50| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11linear_findINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEPNS6_4pairISC_S3_EERKT_: 421| 1.48M| { 422| 2.93M| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (422:31): [True: 1.45M, False: 1.48M] ------------------ 423| 1.45M| if (data_[i].first == key) return data_ + i; ------------------ | Branch (423:17): [True: 0, False: 1.45M] ------------------ 424| 1.45M| } 425| 1.48M| return data_ + size_; 426| 1.48M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE3endEv: 649| 1.48M| iterator end() noexcept { return data_ + size_; } _ZZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEENKUlvE_clEv: 933| 1.48M| return subscript_or_insert(key, [&] { emplace_back_impl(key, mapped_type{}); }); _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE17emplace_back_implIJRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEES3_EEEvDpOT_: 243| 1.48M| { 244| 1.48M| grow_if_needed(); 245| 1.48M| std::construct_at(data_ + size_, std::forward(args)...); 246| 1.48M| ++size_; 247| 1.48M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE14grow_if_neededEv: 217| 1.48M| { 218| 1.48M| if (size_ == capacity_) { ------------------ | Branch (218:14): [True: 501k, False: 979k] ------------------ 219| 501k| if (size_ == max_u32) { ------------------ | Branch (219:17): [True: 0, False: 501k] ------------------ 220| 0| throw_capacity_overflow(); 221| 0| } 222| 501k| const uint32_t new_cap = next_data_capacity(capacity_); 223| 501k| reallocate_data(new_cap); 224| 501k| } 225| 1.48M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE18next_data_capacityEj: 120| 501k| { 121| 501k| if (current == 0) return 4; ------------------ | Branch (121:14): [True: 501k, False: 100] ------------------ 122| 100| if (current > (max_u32 / 2)) return max_u32; ------------------ | Branch (122:14): [True: 0, False: 100] ------------------ 123| 100| return current * 2; 124| 100| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE15reallocate_dataEj: 205| 501k| { 206| 501k| if (new_cap < size_) { ------------------ | Branch (206:14): [True: 0, False: 501k] ------------------ 207| 0| throw_capacity_overflow(); 208| 0| } 209| 501k| auto* new_data = allocate_and_relocate(new_cap); 210| 501k| destroy_all(); 211| 501k| ::operator delete(data_); 212| 501k| data_ = new_data; 213| 501k| capacity_ = new_cap; 214| 501k| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21allocate_and_relocateEj: 159| 501k| { 160| 501k| auto* new_data = static_cast(::operator new(checked_data_allocation_bytes(new_cap))); 161| 501k|#if __cpp_exceptions 162| 501k| uint32_t constructed = 0; 163| 501k| try { 164| 501k| for (; constructed < size_; ++constructed) { ------------------ | Branch (164:20): [True: 600, False: 501k] ------------------ 165| 600| std::construct_at(new_data + constructed, std::move_if_noexcept(data_[constructed])); 166| 600| } 167| 501k| } 168| 501k| catch (...) { 169| 0| destroy_range(new_data, constructed); 170| 0| ::operator delete(new_data); 171| 0| throw; 172| 0| } 173| |#else 174| | for (uint32_t i = 0; i < size_; ++i) { 175| | std::construct_at(new_data + i, std::move_if_noexcept(data_[i])); 176| | } 177| |#endif 178| 501k| return new_data; 179| 501k| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE29checked_data_allocation_bytesEj: 134| 501k| { 135| 501k| if (count > ((std::numeric_limits::max)() / sizeof(value_type))) { ------------------ | Branch (135:14): [True: 0, False: 501k] ------------------ 136| 0| GLZ_THROW_OR_ABORT(std::bad_alloc{}); ------------------ | | 8| 0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC)) ------------------ 137| 0| } 138| 501k| return static_cast(count) * sizeof(value_type); 139| 501k| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE8hash_keyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE: 97| 600| static uint32_t hash_key(std::string_view key) noexcept { return sweethash::sweet32(key); } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE16try_bloom_insertIRZNS4_ixERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEUlvE_EEbjOT_: 529| 150| { 530| 150| if (index_ && size_ <= bloom_threshold && !bloom_maybe_contains(h)) { ------------------ | Branch (530:14): [True: 100, False: 50] | Branch (530:24): [True: 100, False: 0] | Branch (530:52): [True: 100, False: 0] ------------------ 531| | // Definitely not present — skip the search 532| 100| append_fn(); 533| 100| bloom_set(h); 534| | // Index is now stale (index_->size < size_), will rebuild on next lookup or false positive 535| 100| return true; 536| 100| } 537| 50| return false; 538| 150| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE20bloom_maybe_containsEj: 285| 100| { 286| 100| const uint32_t a = h & bloom_mask; 287| 100| const uint32_t b = (h >> 10) & bloom_mask; 288| 100| return (index_->bloom[a >> 3] & (uint8_t(1) << (a & 7))) && (index_->bloom[b >> 3] & (uint8_t(1) << (b & 7))); ------------------ | Branch (288:17): [True: 0, False: 100] | Branch (288:70): [True: 0, False: 0] ------------------ 289| 100| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE17index_find_or_posINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEENS4_17index_find_resultERKT_j: 400| 50| { 401| 50| ensure_index(); 402| | 403| 50| const auto* base = index_entries(); 404| 50| const auto* idx_end = base + index_->size; 405| 50| const auto* p = branchless_lower_bound(base, index_->size, h); 406| 50| const size_t pos = static_cast(p - base); 407| | 408| | // Scan adjacent entries with matching hash 409| 50| for (auto* scan = p; scan != idx_end && scan->key_hash == h; ++scan) { ------------------ | Branch (409:31): [True: 0, False: 50] | Branch (409:50): [True: 0, False: 0] ------------------ 410| 0| if (data_[scan->index].first == key) { ------------------ | Branch (410:17): [True: 0, False: 0] ------------------ 411| 0| return {data_ + scan->index, pos, h}; 412| 0| } 413| 0| } 414| | 415| 50| return {data_ + size_, pos, h}; 416| 50| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE12ensure_indexEv: 360| 50| { 361| 50| if (size_ <= linear_search_threshold) return; ------------------ | Branch (361:14): [True: 0, False: 50] ------------------ 362| 50| const auto current = index_size(); 363| 50| if (current == size_) return; // fully current ------------------ | Branch (363:14): [True: 0, False: 50] ------------------ 364| | 365| 50| if (current == 0 || (size_ - current) > linear_search_threshold) { ------------------ | Branch (365:14): [True: 50, False: 0] | Branch (365:30): [True: 0, False: 0] ------------------ 366| 50| rebuild_index(); // full rebuild 367| 50| return; 368| 50| } 369| | 370| | // Incrementally insert-sort the few new entries 371| 0| for (uint32_t i = current; i < size_; ++i) { ------------------ | Branch (371:37): [True: 0, False: 0] ------------------ 372| 0| const hash_index_entry entry{hash_key(data_[i].first), i}; 373| 0| const auto* base = index_entries(); 374| 0| const auto* p = branchless_lower_bound(base, index_->size, entry.key_hash); 375| 0| auto pos = static_cast(p - base); 376| | 377| 0| const uint32_t m = index_->size; 378| 0| ensure_index_capacity(static_cast(m) + 1); 379| 0| auto* entries = index_entries(); 380| 0| if (pos < m) { ------------------ | Branch (380:17): [True: 0, False: 0] ------------------ 381| 0| std::memmove(entries + pos + 1, entries + pos, (m - pos) * sizeof(hash_index_entry)); 382| 0| } 383| 0| entries[pos] = entry; 384| 0| index_->size = i + 1; 385| 0| } 386| 0| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13rebuild_indexEv: 343| 50| { 344| 50| ensure_index_capacity(static_cast(size_)); 345| 50| bloom_clear(); 346| 50| auto* entries = index_entries(); 347| 500| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (347:31): [True: 450, False: 50] ------------------ 348| 450| const uint32_t h = hash_key(data_[i].first); 349| 450| entries[i] = {h, i}; 350| 450| bloom_set(h); 351| 450| } 352| 50| std::sort(entries, entries + size_, [](const auto& a, const auto& b) { return a.key_hash < b.key_hash; }); 353| 50| index_->size = size_; 354| 50| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11bloom_clearEv: 291| 50| void bloom_clear() const noexcept { std::memset(index_->bloom, 0, bloom_bytes); } _ZZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13rebuild_indexEvENKUlRKT_RKT0_E_clINS4_16hash_index_entryESD_EEDaS7_SA_: 352| 1.25k| std::sort(entries, entries + size_, [](const auto& a, const auto& b) { return a.key_hash < b.key_hash; }); _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE22branchless_lower_boundEPKNS4_16hash_index_entryEmj: 440| 50| { 441| 250| while (len > 1) { ------------------ | Branch (441:17): [True: 200, False: 50] ------------------ 442| 200| size_t half = len / 2; 443| 200| p += (p[half - 1].key_hash < target) * half; 444| 200| len -= half; 445| 200| } 446| | // Final element check: advance past it if it's less than target 447| 50| p += (len == 1 && p->key_hash < target); ------------------ | Branch (447:16): [True: 50, False: 0] | Branch (447:28): [True: 50, False: 0] ------------------ 448| 50| return p; 449| 50| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9bloom_setEj: 277| 600| { 278| 600| const uint32_t a = h & bloom_mask; 279| 600| const uint32_t b = (h >> 10) & bloom_mask; 280| 600| index_->bloom[a >> 3] |= uint8_t(1) << (a & 7); 281| 600| index_->bloom[b >> 3] |= uint8_t(1) << (b & 7); 282| 600| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10index_sizeEv: 300| 100| uint32_t index_size() const noexcept { return index_ ? index_->size : 0; } ------------------ | Branch (300:53): [True: 50, False: 50] ------------------ _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21ensure_index_capacityEm: 314| 100| { 315| 100| if (needed == 0) return; ------------------ | Branch (315:14): [True: 0, False: 100] ------------------ 316| 100| if (needed > static_cast(max_u32)) { ------------------ | Branch (316:14): [True: 0, False: 100] ------------------ 317| 0| throw_index_overflow(); 318| 0| } 319| 100| const auto needed_u32 = static_cast(needed); 320| 100| if (index_ && index_->capacity >= needed_u32) return; ------------------ | Branch (320:14): [True: 50, False: 50] | Branch (320:24): [True: 50, False: 0] ------------------ 321| 50| uint32_t cap = index_ ? index_->capacity : 0; ------------------ | Branch (321:25): [True: 0, False: 50] ------------------ 322| 100| while (cap < needed_u32) { ------------------ | Branch (322:17): [True: 50, False: 50] ------------------ 323| 50| const uint32_t next = next_index_capacity(cap); 324| 50| if (next <= cap) { ------------------ | Branch (324:17): [True: 0, False: 50] ------------------ 325| 0| throw_index_overflow(); 326| 0| } 327| 50| cap = next; 328| 50| } 329| 50| auto* block = static_cast(std::realloc(index_, checked_index_allocation_bytes(cap))); 330| 50| if (!block) GLZ_THROW_OR_ABORT(std::bad_alloc{}); ------------------ | | 8| 0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC)) ------------------ | Branch (330:14): [True: 0, False: 50] ------------------ 331| 50| if (!index_) { ------------------ | Branch (331:14): [True: 50, False: 0] ------------------ 332| 50| block->size = 0; 333| 50| std::memset(block->bloom, 0, bloom_bytes); 334| 50| } 335| 50| block->capacity = cap; 336| 50| index_ = block; 337| 50| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19next_index_capacityEj: 127| 50| { 128| 50| if (current == 0) return 16; ------------------ | Branch (128:14): [True: 50, False: 0] ------------------ 129| 0| if (current > (max_u32 / 2)) return max_u32; ------------------ | Branch (129:14): [True: 0, False: 0] ------------------ 130| 0| return current * 2; 131| 0| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE30checked_index_allocation_bytesEj: 142| 50| { 143| 50| constexpr size_t header = sizeof(index_header); 144| 50| constexpr size_t entry = sizeof(hash_index_entry); 145| 50| if (count > (((std::numeric_limits::max)() - header) / entry)) { ------------------ | Branch (145:14): [True: 0, False: 50] ------------------ 146| 0| GLZ_THROW_OR_ABORT(std::bad_alloc{}); ------------------ | | 8| 0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC)) ------------------ 147| 0| } 148| 50| return header + static_cast(count) * entry; 149| 50| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13index_entriesEv: 296| 150| { 297| 150| return static_cast(static_cast(index_ + 1)); 298| 150| } _ZN3glz12ensure_spaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_RT_m: 210| 4.50M| { 211| 4.50M| using Buffer = std::remove_cvref_t; 212| | 213| 4.50M| if constexpr (vector_like) { 214| 4.50M| if (required > b.size()) [[unlikely]] { ------------------ | Branch (214:14): [True: 1.35k, False: 4.50M] ------------------ 215| 1.35k| grow_buffer(b, required); 216| 1.35k| } 217| 4.50M| return true; 218| | } 219| | else if constexpr (has_bounded_capacity) { 220| | if (required > buffer_traits::capacity(b)) [[unlikely]] { 221| | ctx.error = error_code::buffer_overflow; 222| | return false; 223| | } 224| | return true; 225| | } 226| | else { 227| | return true; // Raw pointer or other - trust caller 228| | } 229| 4.50M| } _ZN3glz11grow_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m: 88| 1.35k| { 89| 1.35k| using traits = buffer_traits>; 90| 1.35k| if constexpr (requires { traits::grow(b, required); }) { 91| 1.35k| traits::grow(b, required); 92| | } 93| | else { 94| | // A user specialization written before `grow` existed: keep the growth it used to get. 95| | b.resize(2 * required); 96| | } 97| 1.35k| } _ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE4growERS7_mQL_ZNS_13buffer_traits12is_resizableEE: 63| 1.35k| { 64| 1.35k| b.resize(2 * required); 65| 1.35k| } _ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE8finalizeERS7_m: 69| 4.50M| { 70| 4.50M| if constexpr (is_resizable) { 71| 4.50M| b.resize(written); 72| 4.50M| } 73| | // For fixed buffers: no-op, count is returned in result 74| 4.50M| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_iEEDcOT_OT0_: 616| 66.7k| { 617| 66.7k| using V = std::decay_t; 618| 66.7k| if constexpr (std::is_member_object_pointer_v) { 619| 66.7k| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 66.7k| } _ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_EENS1_17basic_string_viewIcS4_EEOT0_: 288| 47.1k| { 289| | if constexpr (std::same_as, std::string_view>) { 290| | return value; // already the answer; rebuilding it from data() and size() costs instructions 291| | } 292| | else if constexpr (!char_array_t && std::is_pointer_v>) { 293| | return value ? std::string_view{value} : std::string_view{}; 294| | } 295| 47.1k| else if constexpr (has_data && has_size) { 296| 47.1k| return std::string_view{value.data(), value.size()}; 297| | } 298| | else { 299| | return std::string_view{value}; 300| | } 301| 47.1k| } _ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERS5_EES5_OT0_: 288| 5.38k| { 289| 5.38k| if constexpr (std::same_as, std::string_view>) { 290| 5.38k| return value; // already the answer; rebuilding it from data() and size() costs instructions 291| | } 292| | else if constexpr (!char_array_t && std::is_pointer_v>) { 293| | return value ? std::string_view{value} : std::string_view{}; 294| | } 295| | else if constexpr (has_data && has_size) { 296| | return std::string_view{value.data(), value.size()}; 297| | } 298| | else { 299| | return std::string_view{value}; 300| | } 301| 5.38k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FiiEEEDcOT_OT0_: 616| 66.7k| { 617| 66.7k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 66.7k| else if constexpr (std::is_member_function_pointer_v) { 622| 66.7k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 66.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FvvEEEDcOT_OT0_: 616| 66.7k| { 617| 66.7k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 66.7k| else if constexpr (std::is_member_function_pointer_v) { 622| 66.7k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 66.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FNS1_5pointERKS4_EEEDcOT_OT0_: 616| 66.7k| { 617| 66.7k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 66.7k| else if constexpr (std::is_member_function_pointer_v) { 622| 66.7k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 66.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz5pointERdEEDcOT_OT0_: 616| 141k| { 617| 141k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 141k| else { 639| 141k| return element; 640| 141k| } 641| 141k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERiEEDcOT_OT0_: 616| 80.6k| { 617| 80.6k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 80.6k| else { 639| 80.6k| return element; 640| 80.6k| } 641| 80.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 616| 66.9k| { 617| 66.9k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 66.9k| else { 639| 66.9k| return element; 640| 66.9k| } 641| 66.9k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_5pointEEEDcOT_OT0_: 616| 67.4k| { 617| 67.4k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.4k| else { 639| 67.4k| return element; 640| 67.4k| } 641| 67.4k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERiEEDcOT_OT0_: 616| 79.6k| { 617| 79.6k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 79.6k| else { 639| 79.6k| return element; 640| 79.6k| } 641| 79.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 616| 67.6k| { 617| 67.6k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.6k| else { 639| 67.6k| return element; 640| 67.6k| } 641| 67.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_6nestedEEEDcOT_OT0_: 616| 67.6k| { 617| 67.6k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.6k| else { 639| 67.6k| return element; 640| 67.6k| } 641| 67.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__16vectorIiNS4_9allocatorIiEEEEEEDcOT_OT0_: 616| 73.6k| { 617| 73.6k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 73.6k| else { 639| 73.6k| return element; 640| 73.6k| } 641| 73.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEEEEDcOT_OT0_: 616| 67.9k| { 617| 67.9k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.9k| else { 639| 67.9k| return element; 640| 67.9k| } 641| 67.9k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18optionalIdEEEEDcOT_OT0_: 616| 68.1k| { 617| 68.1k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 68.1k| else { 639| 68.1k| return element; 640| 68.1k| } 641| 68.1k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6amountERdEEDcOT_OT0_: 616| 315| { 617| 315| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 315| else { 639| 315| return element; 640| 315| } 641| 315| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_6amountEEEEEEDcOT_OT0_: 616| 67.9k| { 617| 67.9k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.9k| else { 639| 67.9k| return element; 640| 67.9k| } 641| 67.9k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFiiEEEEEDcOT_OT0_: 616| 67.0k| { 617| 67.0k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.0k| else { 639| 67.0k| return element; 640| 67.0k| } 641| 67.0k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEEEEDcOT_OT0_: 616| 67.0k| { 617| 67.0k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 67.0k| else { 639| 67.0k| return element; 640| 67.0k| } 641| 67.0k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS1_5pointERKS6_EEEEEDcOT_OT0_: 616| 66.8k| { 617| 66.8k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 66.8k| else { 639| 66.8k| return element; 640| 66.8k| } 641| 66.8k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEEEEDcOT_OT0_: 616| 66.8k| { 617| 66.8k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 66.8k| else { 639| 66.8k| return element; 640| 66.8k| } 641| 66.8k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFvvEEEEEDcOT_OT0_: 616| 66.9k| { 617| 66.9k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 66.9k| else { 639| 66.9k| return element; 640| 66.9k| } 641| 66.9k| } _ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_EENS1_17basic_string_viewIcS4_EEOT0_: 288| 4.41M| { 289| | if constexpr (std::same_as, std::string_view>) { 290| | return value; // already the answer; rebuilding it from data() and size() costs instructions 291| | } 292| | else if constexpr (!char_array_t && std::is_pointer_v>) { 293| | return value ? std::string_view{value} : std::string_view{}; 294| | } 295| 4.41M| else if constexpr (has_data && has_size) { 296| 4.41M| return std::string_view{value.data(), value.size()}; 297| | } 298| | else { 299| | return std::string_view{value}; 300| | } 301| 4.41M| } _ZN3glz14basic_raw_jsonINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEC2Ev: 178| 9.65M| basic_raw_json() = default; _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__18optionalINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEEEEDcOT_OT0_: 616| 119k| { 617| 119k| using V = std::decay_t; 618| 119k| if constexpr (std::is_member_object_pointer_v) { 619| 119k| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 119k| } _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEEDcOT_OT0_: 616| 39.3k| { 617| 39.3k| using V = std::decay_t; 618| 39.3k| if constexpr (std::is_member_object_pointer_v) { 619| 39.3k| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 39.3k| } _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEEEEDcOT_OT0_: 616| 79.4k| { 617| 79.4k| using V = std::decay_t; 618| 79.4k| if constexpr (std::is_member_object_pointer_v) { 619| 79.4k| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 79.4k| } _ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKS5_EES5_OT0_: 288| 37| { 289| 37| if constexpr (std::same_as, std::string_view>) { 290| 37| return value; // already the answer; rebuilding it from data() and size() costs instructions 291| | } 292| | else if constexpr (!char_array_t && std::is_pointer_v>) { 293| | return value ? std::string_view{value} : std::string_view{}; 294| | } 295| | else if constexpr (has_data && has_size) { 296| | return std::string_view{value.data(), value.size()}; 297| | } 298| | else { 299| | return std::string_view{value}; 300| | } 301| 37| } _ZN3glz10get_memberIRNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEERKMS4_NSt3__17variantIJDndNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEbNS6_6vectorIS4_NSB_IS4_EEEENS3_IS4_EEEEEEEDcOT_OT0_: 616| 1.75M| { 617| 1.75M| using V = std::decay_t; 618| 1.75M| if constexpr (std::is_member_object_pointer_v) { 619| 1.75M| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 1.75M| } _ZN3glz11enter_depthITkNS_10is_contextENS_7contextEEEbRT_: 281| 1.17M| { 282| 1.17M| if (ctx.depth >= max_recursive_depth_limit) [[unlikely]] { ------------------ | Branch (282:11): [True: 1.13k, False: 1.17M] ------------------ 283| 1.13k| ctx.error = error_code::exceeded_max_recursive_depth; 284| 1.13k| return true; 285| 1.13k| } 286| 1.17M| ++ctx.depth; 287| 1.17M| return false; 288| 1.17M| } _ZNK3glz9error_ctxcvbEv: 136| 13.4M| operator bool() const noexcept { return ec != error_code::none; } _ZN3glz18charge_speculationITkNS_10is_contextENS_7contextEEEbRT_m: 249| 50.6k| { 250| 50.6k| if constexpr (requires { ctx.speculation_budget; }) { 251| 50.6k| if (ctx.speculation_budget == 0) { ------------------ | Branch (251:14): [True: 0, False: 50.6k] ------------------ 252| 0| return true; 253| 0| } 254| 50.6k| ctx.speculation_budget = consumed >= ctx.speculation_budget ? 1 : ctx.speculation_budget - consumed; ------------------ | Branch (254:35): [True: 0, False: 50.6k] ------------------ 255| 50.6k| return ctx.speculation_budget > 1; 256| | } 257| | else { 258| | return true; 259| | } 260| 50.6k| } _ZN3glz21speculation_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 266| 2.08k| { 267| 2.08k| if constexpr (requires { ctx.speculation_budget; }) { 268| 2.08k| return ctx.speculation_budget == 1; // the latched floor; 0 means unbudgeted 269| | } 270| | else { 271| | return false; 272| | } 273| 2.08k| } _ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ETkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDaOT1_: 40| 605k| { 41| 605k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 605k| auto it = reinterpret_cast(buffer.data()); 44| 605k| auto end = reinterpret_cast(buffer.data()); // to be incremented 45| | 46| | if constexpr (Padded) { 47| | end += buffer.size() - padding_bytes; 48| | } 49| 605k| else { 50| 605k| end += buffer.size(); 51| 605k| } 52| | 53| 605k| return std::pair{it, end}; 54| 605k| } _ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_: 115| 507k| { 116| 507k| if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) { 117| | // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every 118| | // successful read, which is the ordinary case for a registry parsing a wire span. 119| | // start < it, not !=, because a streaming origin can be empty or overshoot on an error 120| | // path; neither is an absent value. 121| 507k| if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) { ------------------ | Branch (121:14): [True: 91.4k, False: 415k] | Branch (121:54): [True: 90.7k, False: 735] | Branch (121:72): [True: 89.6k, False: 1.11k] | Branch (121:85): [True: 89.6k, False: 0] ------------------ 122| 89.6k| context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused 123| 89.6k| const char* consumed = start; 124| 89.6k| skip_ws(ws_ctx, consumed, it); 125| 89.6k| if (consumed == it) { ------------------ | Branch (125:17): [True: 13, False: 89.5k] ------------------ 126| 13| ctx.error = error_code::no_read_input; 127| 13| } 128| 89.6k| } 129| 507k| } 130| 507k| finalize_read_context(ctx); 131| 507k| } _ZN3glz21finalize_read_contextITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_: 76| 507k| { 77| | // A partial read stops as soon as it has the fields it was asked for, so it unwinds through 78| | // its enclosing containers on an error code rather than through their closing braces, and 79| | // none of them decrement depth on the way out. Depth is left standing at whatever nesting the 80| | // last field sat at. 81| | // 82| | // That has to be cleared here rather than left for the next read to trip over. This is the 83| | // one path that reports success with depth still raised, and depth is what settle_end_reached 84| | // reads to tell a completed parse from a truncated one -- so a context reused after a partial 85| | // read would see a later well-formed buffer settle to unexpected_end. Reads that end any 86| | // other way either return depth to zero themselves or carry an error, and a context holding 87| | // an error short-circuits the next read before it parses anything. 88| | if constexpr (check_partial_read(Opts)) { 89| | if (ctx.error == error_code::partial_read_complete) [[likely]] { 90| | ctx.error = error_code::none; 91| | ctx.depth = 0; 92| | return; 93| | } 94| | } 95| 507k| settle_end_reached(ctx); 96| 507k| } _ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_: 68| 824k| { 69| 824k| if (ctx.error == error_code::end_reached) { ------------------ | Branch (69:11): [True: 113k, False: 711k] ------------------ 70| 113k| ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end; ------------------ | Branch (70:22): [True: 112k, False: 917] ------------------ 71| 113k| } 72| 824k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_: 219| 1.28k| { 220| 1.28k| format_context_t ctx{}; 221| 1.28k| return read(value, buffer, ctx); 222| 1.28k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_: 136| 1.28k| { 137| 1.28k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.28k| using Buffer = std::remove_reference_t; 139| | 140| 1.28k| if constexpr (Opts.format != NDJSON) { 141| 1.28k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.28k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.28k| } 146| | 147| 1.28k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.28k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.28k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.28k| auto [it, end] = read_iterators(buffer); 157| 1.28k| auto start = it; 158| 1.28k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.28k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.28k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.28k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.28k| ctx.speculation_budget = 167| 1.28k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 11, False: 1.27k] ------------------ 168| 1.28k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.28k| else { 183| 1.28k| parse::template op()>(value, ctx, it, end); 184| 1.28k| } 185| | 186| 1.28k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.14k, False: 143] ------------------ 187| 1.14k| goto finish; 188| 1.14k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.28k| finish: 206| 1.28k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.28k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 143| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 219| 1.17k| { 220| 1.17k| format_context_t ctx{}; 221| 1.17k| return read(value, buffer, ctx); 222| 1.17k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 136| 1.17k| { 137| 1.17k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.17k| using Buffer = std::remove_reference_t; 139| | 140| 1.17k| if constexpr (Opts.format != NDJSON) { 141| 1.17k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.17k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.17k| } 146| | 147| 1.17k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.17k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.17k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.17k| auto [it, end] = read_iterators(buffer); 157| 1.17k| auto start = it; 158| 1.17k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.17k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.17k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.17k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.17k| ctx.speculation_budget = 167| 1.17k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 7, False: 1.17k] ------------------ 168| 1.17k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.17k| else { 183| 1.17k| parse::template op()>(value, ctx, it, end); 184| 1.17k| } 185| | 186| 1.17k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.17k, False: 0] ------------------ 187| 1.17k| goto finish; 188| 1.17k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.17k| finish: 206| 1.17k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.17k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 219| 7.78k| { 220| 7.78k| format_context_t ctx{}; 221| 7.78k| return read(value, buffer, ctx); 222| 7.78k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 136| 7.78k| { 137| 7.78k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 7.78k| using Buffer = std::remove_reference_t; 139| | 140| 7.78k| if constexpr (Opts.format != NDJSON) { 141| 7.78k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 7.78k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 7.78k| } 146| | 147| 7.78k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 7.78k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 7.78k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 7.78k| auto [it, end] = read_iterators(buffer); 157| 7.78k| auto start = it; 158| 7.78k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 7.78k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 7.78k| if constexpr (requires { ctx.speculation_budget; }) { 165| 7.78k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 7.78k| ctx.speculation_budget = 167| 7.78k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 89, False: 7.69k] ------------------ 168| 7.78k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 7.78k| else { 183| 7.78k| parse::template op()>(value, ctx, it, end); 184| 7.78k| } 185| | 186| 7.78k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 7.78k, False: 0] ------------------ 187| 7.78k| goto finish; 188| 7.78k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 7.78k| finish: 206| 7.78k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 7.78k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10contiguousERNS2_17basic_string_viewIcS5_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 219| 1.22k| { 220| 1.22k| format_context_t ctx{}; 221| 1.22k| return read(value, buffer, ctx); 222| 1.22k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10contiguousERNS2_17basic_string_viewIcS5_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 136| 1.22k| { 137| 1.22k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.22k| using Buffer = std::remove_reference_t; 139| | 140| 1.22k| if constexpr (Opts.format != NDJSON) { 141| 1.22k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.22k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.22k| } 146| | 147| 1.22k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.22k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.22k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.22k| auto [it, end] = read_iterators(buffer); 157| 1.22k| auto start = it; 158| 1.22k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.22k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.22k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.22k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.22k| ctx.speculation_budget = 167| 1.22k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 37, False: 1.18k] ------------------ 168| 1.22k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.22k| else { 183| 1.22k| parse::template op()>(value, ctx, it, end); 184| 1.22k| } 185| | 186| 1.22k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 761, False: 460] ------------------ 187| 761| goto finish; 188| 761| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.22k| finish: 206| 1.22k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.22k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 460| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_: 219| 607| { 220| 607| format_context_t ctx{}; 221| 607| return read(value, buffer, ctx); 222| 607| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_: 136| 607| { 137| 607| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 607| using Buffer = std::remove_reference_t; 139| | 140| 607| if constexpr (Opts.format != NDJSON) { 141| 607| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 607] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 607| } 146| | 147| 607| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 607] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 607| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 607| auto [it, end] = read_iterators(buffer); 157| 607| auto start = it; 158| 607| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 607] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 607| if constexpr (requires { ctx.speculation_budget; }) { 165| 607| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 607| ctx.speculation_budget = 167| 607| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 0, False: 607] ------------------ 168| 607| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 607| else { 183| 607| parse::template op()>(value, ctx, it, end); 184| 607| } 185| | 186| 607| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 537, False: 70] ------------------ 187| 537| goto finish; 188| 537| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 607| finish: 206| 607| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 607| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 70| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 219| 1.62k| { 220| 1.62k| format_context_t ctx{}; 221| 1.62k| return read(value, buffer, ctx); 222| 1.62k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 136| 1.62k| { 137| 1.62k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.62k| using Buffer = std::remove_reference_t; 139| | 140| 1.62k| if constexpr (Opts.format != NDJSON) { 141| 1.62k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.62k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.62k| } 146| | 147| 1.62k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.62k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.62k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.62k| auto [it, end] = read_iterators(buffer); 157| 1.62k| auto start = it; 158| 1.62k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.62k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.62k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.62k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.62k| ctx.speculation_budget = 167| 1.62k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 17, False: 1.60k] ------------------ 168| 1.62k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.62k| else { 183| 1.62k| parse::template op()>(value, ctx, it, end); 184| 1.62k| } 185| | 186| 1.62k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.62k, False: 0] ------------------ 187| 1.62k| goto finish; 188| 1.62k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.62k| finish: 206| 1.62k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.62k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 219| 2.03k| { 220| 2.03k| format_context_t ctx{}; 221| 2.03k| return read(value, buffer, ctx); 222| 2.03k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 136| 2.03k| { 137| 2.03k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 2.03k| using Buffer = std::remove_reference_t; 139| | 140| 2.03k| if constexpr (Opts.format != NDJSON) { 141| 2.03k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 2.03k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 2.03k| } 146| | 147| 2.03k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 2.03k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 2.03k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 2.03k| auto [it, end] = read_iterators(buffer); 157| 2.03k| auto start = it; 158| 2.03k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 2.03k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 2.03k| if constexpr (requires { ctx.speculation_budget; }) { 165| 2.03k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 2.03k| ctx.speculation_budget = 167| 2.03k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 28, False: 2.00k] ------------------ 168| 2.03k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 2.03k| else { 183| 2.03k| parse::template op()>(value, ctx, it, end); 184| 2.03k| } 185| | 186| 2.03k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.59k, False: 441] ------------------ 187| 1.59k| goto finish; 188| 1.59k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 2.03k| finish: 206| 2.03k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 2.03k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 441| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSK_OSL_: 219| 1.91k| { 220| 1.91k| format_context_t ctx{}; 221| 1.91k| return read(value, buffer, ctx); 222| 1.91k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSM_OSN_OT2_: 136| 1.91k| { 137| 1.91k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.91k| using Buffer = std::remove_reference_t; 139| | 140| 1.91k| if constexpr (Opts.format != NDJSON) { 141| 1.91k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.91k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.91k| } 146| | 147| 1.91k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.91k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.91k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.91k| auto [it, end] = read_iterators(buffer); 157| 1.91k| auto start = it; 158| 1.91k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.91k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.91k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.91k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.91k| ctx.speculation_budget = 167| 1.91k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 20, False: 1.89k] ------------------ 168| 1.91k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.91k| else { 183| 1.91k| parse::template op()>(value, ctx, it, end); 184| 1.91k| } 185| | 186| 1.91k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.91k, False: 0] ------------------ 187| 1.91k| goto finish; 188| 1.91k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.91k| finish: 206| 1.91k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.91k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 219| 2.08k| { 220| 2.08k| format_context_t ctx{}; 221| 2.08k| return read(value, buffer, ctx); 222| 2.08k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 136| 2.08k| { 137| 2.08k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 2.08k| using Buffer = std::remove_reference_t; 139| | 140| 2.08k| if constexpr (Opts.format != NDJSON) { 141| 2.08k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 2.08k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 2.08k| } 146| | 147| 2.08k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 2.08k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 2.08k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 2.08k| auto [it, end] = read_iterators(buffer); 157| 2.08k| auto start = it; 158| 2.08k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 2.08k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 2.08k| if constexpr (requires { ctx.speculation_budget; }) { 165| 2.08k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 2.08k| ctx.speculation_budget = 167| 2.08k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 23, False: 2.06k] ------------------ 168| 2.08k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 2.08k| else { 183| 2.08k| parse::template op()>(value, ctx, it, end); 184| 2.08k| } 185| | 186| 2.08k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 1.87k, False: 213] ------------------ 187| 1.87k| goto finish; 188| 1.87k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 2.08k| finish: 206| 2.08k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 2.08k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 213| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_: 219| 1.10k| { 220| 1.10k| format_context_t ctx{}; 221| 1.10k| return read(value, buffer, ctx); 222| 1.10k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSI_OSJ_OT2_: 136| 1.10k| { 137| 1.10k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 1.10k| using Buffer = std::remove_reference_t; 139| | 140| 1.10k| if constexpr (Opts.format != NDJSON) { 141| 1.10k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 1.10k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 1.10k| } 146| | 147| 1.10k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 1.10k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 1.10k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 1.10k| auto [it, end] = read_iterators(buffer); 157| 1.10k| auto start = it; 158| 1.10k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 1.10k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 1.10k| if constexpr (requires { ctx.speculation_budget; }) { 165| 1.10k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 1.10k| ctx.speculation_budget = 167| 1.10k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 26, False: 1.08k] ------------------ 168| 1.10k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 1.10k| else { 183| 1.10k| parse::template op()>(value, ctx, it, end); 184| 1.10k| } 185| | 186| 1.10k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 763, False: 343] ------------------ 187| 763| goto finish; 188| 763| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 1.10k| finish: 206| 1.10k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 1.10k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 343| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 219| 3.92k| { 220| 3.92k| format_context_t ctx{}; 221| 3.92k| return read(value, buffer, ctx); 222| 3.92k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 136| 3.92k| { 137| 3.92k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 3.92k| using Buffer = std::remove_reference_t; 139| | 140| 3.92k| if constexpr (Opts.format != NDJSON) { 141| 3.92k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 3.92k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 3.92k| } 146| | 147| 3.92k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 3.92k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 3.92k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 3.92k| auto [it, end] = read_iterators(buffer); 157| 3.92k| auto start = it; 158| 3.92k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 3.92k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 3.92k| if constexpr (requires { ctx.speculation_budget; }) { 165| 3.92k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 3.92k| ctx.speculation_budget = 167| 3.92k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 38, False: 3.88k] ------------------ 168| 3.92k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 3.92k| else { 183| 3.92k| parse::template op()>(value, ctx, it, end); 184| 3.92k| } 185| | 186| 3.92k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 2.04k, False: 1.87k] ------------------ 187| 2.04k| goto finish; 188| 2.04k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 3.92k| finish: 206| 3.92k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 3.92k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 1.87k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorINS_14basic_raw_jsonINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_9allocatorIS9_EEEETkNS_10contiguousERS8_Qaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_: 219| 25.3k| { 220| 25.3k| format_context_t ctx{}; 221| 25.3k| return read(value, buffer, ctx); 222| 25.3k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorINS_14basic_raw_jsonINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_9allocatorIS9_EEEETkNS_10contiguousERS8_TkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_OT2_: 136| 25.3k| { 137| 25.3k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 25.3k| using Buffer = std::remove_reference_t; 139| | 140| 25.3k| if constexpr (Opts.format != NDJSON) { 141| 25.3k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 25.3k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 25.3k| } 146| | 147| 25.3k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 25.3k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 25.3k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 25.3k| auto [it, end] = read_iterators(buffer); 157| 25.3k| auto start = it; 158| 25.3k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 25.3k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 25.3k| if constexpr (requires { ctx.speculation_budget; }) { 165| 25.3k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 25.3k| ctx.speculation_budget = 167| 25.3k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 590, False: 24.7k] ------------------ 168| 25.3k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 25.3k| else { 183| 25.3k| parse::template op()>(value, ctx, it, end); 184| 25.3k| } 185| | 186| 25.3k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 7.27k, False: 18.1k] ------------------ 187| 7.27k| goto finish; 188| 7.27k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 25.3k| finish: 206| 25.3k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 25.3k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 18.1k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 219| 4.46M| { 220| 4.46M| format_context_t ctx{}; 221| 4.46M| return read(value, buffer, ctx); 222| 4.46M| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 136| 4.46M| { 137| 4.46M| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 4.46M| using Buffer = std::remove_reference_t; 139| | 140| 4.46M| if constexpr (Opts.format != NDJSON) { 141| 4.46M| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 4.08M, False: 379k] ------------------ 142| 4.08M| ctx.error = error_code::no_read_input; 143| 4.08M| return {0, ctx.error, ctx.custom_error_message}; 144| 4.08M| } 145| 4.46M| } 146| | 147| 4.46M| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 4.46M] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 4.46M| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 4.46M| auto [it, end] = read_iterators(buffer); 157| 4.46M| auto start = it; 158| 4.46M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 4.46M] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 4.46M| if constexpr (requires { ctx.speculation_budget; }) { 165| 4.46M| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 4.46M| ctx.speculation_budget = 167| 4.46M| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 1.14k, False: 4.46M] ------------------ 168| 4.46M| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 4.46M| else { 183| 4.46M| parse::template op()>(value, ctx, it, end); 184| 4.46M| } 185| | 186| 4.46M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 375k, False: 4.09M] ------------------ 187| 375k| goto finish; 188| 375k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 4.09M| finish: 206| 379k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 379k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 4.09M| } _ZN3glz4readITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEENS_4skipETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSD_OSE_OT2_: 136| 4.40M| { 137| 4.40M| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 4.40M| using Buffer = std::remove_reference_t; 139| | 140| 4.40M| if constexpr (Opts.format != NDJSON) { 141| 4.40M| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 4.08M, False: 317k] ------------------ 142| 4.08M| ctx.error = error_code::no_read_input; 143| 4.08M| return {0, ctx.error, ctx.custom_error_message}; 144| 4.08M| } 145| 4.40M| } 146| | 147| 4.40M| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 4.40M] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 4.40M| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 4.40M| auto [it, end] = read_iterators(buffer); 157| 4.40M| auto start = it; 158| 4.40M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 4.40M] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 4.40M| if constexpr (requires { ctx.speculation_budget; }) { 165| 4.40M| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 4.40M| ctx.speculation_budget = 167| 4.40M| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 660, False: 4.40M] ------------------ 168| 4.40M| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 4.40M| else { 183| 4.40M| parse::template op()>(value, ctx, it, end); 184| 4.40M| } 185| | 186| 4.40M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 223k, False: 4.18M] ------------------ 187| 223k| goto finish; 188| 223k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| 4.18M| if constexpr (check_validate_trailing_whitespace(Opts)) { 194| 4.18M| if (it < end) { ------------------ | Branch (194:14): [True: 4.15k, False: 4.17M] ------------------ 195| 4.15k| skip_ws(ctx, it, end); 196| 4.15k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (196:17): [True: 328, False: 3.82k] ------------------ 197| 328| goto finish; 198| 328| } 199| 3.82k| if (it != end) [[unlikely]] { ------------------ | Branch (199:17): [True: 3.82k, False: 0] ------------------ 200| 3.82k| ctx.error = error_code::syntax_error; 201| 3.82k| } 202| 3.82k| } 203| 4.18M| } 204| | 205| 4.18M| finish: 206| 317k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 317k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 4.18M| } _ZN3glz14read_iteratorsITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEELb0ETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEDaOT1_: 40| 317k| { 41| 317k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 317k| auto it = reinterpret_cast(buffer.data()); 44| 317k| auto end = reinterpret_cast(buffer.data()); // to be incremented 45| | 46| | if constexpr (Padded) { 47| | end += buffer.size() - padding_bytes; 48| | } 49| 317k| else { 50| 317k| end += buffer.size(); 51| 317k| } 52| | 53| 317k| return std::pair{it, end}; 54| 317k| } _ZN3glz23finalize_top_level_readITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS9_S9_: 115| 317k| { 116| 317k| if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) { 117| | // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every 118| | // successful read, which is the ordinary case for a registry parsing a wire span. 119| | // start < it, not !=, because a streaming origin can be empty or overshoot on an error 120| | // path; neither is an absent value. 121| 317k| if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) { ------------------ | Branch (121:14): [True: 21.9k, False: 295k] | Branch (121:54): [True: 21.7k, False: 182] | Branch (121:72): [True: 21.7k, False: 0] | Branch (121:85): [True: 21.7k, False: 0] ------------------ 122| 21.7k| context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused 123| 21.7k| const char* consumed = start; 124| 21.7k| skip_ws(ws_ctx, consumed, it); 125| 21.7k| if (consumed == it) { ------------------ | Branch (125:17): [True: 13, False: 21.7k] ------------------ 126| 13| ctx.error = error_code::no_read_input; 127| 13| } 128| 21.7k| } 129| 317k| } 130| 317k| finalize_read_context(ctx); 131| 317k| } _ZN3glz21finalize_read_contextITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_: 76| 317k| { 77| | // A partial read stops as soon as it has the fields it was asked for, so it unwinds through 78| | // its enclosing containers on an error code rather than through their closing braces, and 79| | // none of them decrement depth on the way out. Depth is left standing at whatever nesting the 80| | // last field sat at. 81| | // 82| | // That has to be cleared here rather than left for the next read to trip over. This is the 83| | // one path that reports success with depth still raised, and depth is what settle_end_reached 84| | // reads to tell a completed parse from a truncated one -- so a context reused after a partial 85| | // read would see a later well-formed buffer settle to unexpected_end. Reads that end any 86| | // other way either return depth to zero themselves or carry an error, and a context holding 87| | // an error short-circuits the next read before it parses anything. 88| | if constexpr (check_partial_read(Opts)) { 89| | if (ctx.error == error_code::partial_read_complete) [[likely]] { 90| | ctx.error = error_code::none; 91| | ctx.depth = 0; 92| | return; 93| | } 94| | } 95| 317k| settle_end_reached(ctx); 96| 317k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEETkNS_10contiguousERKNS2_4spanIKcLm18446744073709551615EEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_OT2_: 136| 14.1k| { 137| 14.1k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 14.1k| using Buffer = std::remove_reference_t; 139| | 140| 14.1k| if constexpr (Opts.format != NDJSON) { 141| 14.1k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 14.1k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 14.1k| } 146| | 147| 14.1k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 14.1k] | Branch (147:56): [Folded, False: 0] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 14.1k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 14.1k| auto [it, end] = read_iterators(buffer); 157| 14.1k| auto start = it; 158| 14.1k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 14.1k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 14.1k| if constexpr (requires { ctx.speculation_budget; }) { 165| 14.1k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 14.1k| ctx.speculation_budget = 167| 14.1k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 24, False: 14.1k] ------------------ 168| 14.1k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 14.1k| else { 183| 14.1k| parse::template op()>(value, ctx, it, end); 184| 14.1k| } 185| | 186| 14.1k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 12.1k, False: 2.08k] ------------------ 187| 12.1k| goto finish; 188| 12.1k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 14.1k| finish: 206| 14.1k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 14.1k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 2.08k| } _ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ETkNS_10contiguousERKNSt3__14spanIKcLm18446744073709551615EEEEEDaOT1_: 40| 14.1k| { 41| 14.1k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 14.1k| auto it = reinterpret_cast(buffer.data()); 44| 14.1k| auto end = reinterpret_cast(buffer.data()); // to be incremented 45| | 46| | if constexpr (Padded) { 47| | end += buffer.size() - padding_bytes; 48| | } 49| 14.1k| else { 50| 14.1k| end += buffer.size(); 51| 14.1k| } 52| | 53| 14.1k| return std::pair{it, end}; 54| 14.1k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10contiguousENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSB_OSC_: 219| 63.0k| { 220| 63.0k| format_context_t ctx{}; 221| 63.0k| return read(value, buffer, ctx); 222| 63.0k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 136| 63.0k| { 137| 63.0k| static_assert(sizeof(decltype(*buffer.data())) == 1); 138| 63.0k| using Buffer = std::remove_reference_t; 139| | 140| 63.0k| if constexpr (Opts.format != NDJSON) { 141| 63.0k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (141:14): [True: 0, False: 63.0k] ------------------ 142| 0| ctx.error = error_code::no_read_input; 143| 0| return {0, ctx.error, ctx.custom_error_message}; 144| 0| } 145| 63.0k| } 146| | 147| 63.0k| constexpr bool use_padded = resizable && non_const_buffer && !check_disable_padding(Opts); ------------------ | Branch (147:35): [Folded, False: 63.0k] | Branch (147:56): [True: 0, Folded] | Branch (147:84): [True: 0, Folded] ------------------ 148| | 149| 63.0k| [[maybe_unused]] size_t original_size{}; 150| | if constexpr (use_padded) { 151| | // Pad the buffer for SWAR 152| | original_size = buffer.size(); 153| | buffer.resize(original_size + padding_bytes); 154| | } 155| | 156| 63.0k| auto [it, end] = read_iterators(buffer); 157| 63.0k| auto start = it; 158| 63.0k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (158:11): [True: 0, False: 63.0k] ------------------ 159| 0| goto finish; 160| 0| } 161| | 162| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 163| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 164| 63.0k| if constexpr (requires { ctx.speculation_budget; }) { 165| 63.0k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 166| 63.0k| ctx.speculation_budget = 167| 63.0k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (167:14): [True: 308, False: 62.7k] ------------------ 168| 63.0k| } 169| | 170| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 171| | // there, so clearing it here is what makes those budgets per-read like the one above. A 172| | // reused context would otherwise carry a spent budget into the next document and reject a 173| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 174| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 175| | if constexpr (requires { ctx.stream_begin; }) { 176| | ctx.stream_begin = nullptr; 177| | } 178| | 179| | if constexpr (use_padded) { 180| | parse::template op()>(value, ctx, it, end); 181| | } 182| 63.0k| else { 183| 63.0k| parse::template op()>(value, ctx, it, end); 184| 63.0k| } 185| | 186| 63.0k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:11): [True: 51.1k, False: 11.9k] ------------------ 187| 51.1k| goto finish; 188| 51.1k| } 189| | 190| | // The JSON RFC 8259 defines: JSON-text = ws value ws 191| | // So, trailing whitespace is permitted and sometimes we want to 192| | // validate this, even though this memory will not affect Glaze. 193| | if constexpr (check_validate_trailing_whitespace(Opts)) { 194| | if (it < end) { 195| | skip_ws(ctx, it, end); 196| | if (bool(ctx.error)) [[unlikely]] { 197| | goto finish; 198| | } 199| | if (it != end) [[unlikely]] { 200| | ctx.error = error_code::syntax_error; 201| | } 202| | } 203| | } 204| | 205| 63.0k| finish: 206| 63.0k| finalize_top_level_read(ctx, start, it, end); 207| | 208| | if constexpr (use_padded) { 209| | // Restore the original buffer state 210| | buffer.resize(original_size); 211| | } 212| | 213| 63.0k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 214| 11.9k| } _ZN3glz12format_errorINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKNS_9error_ctxERKT_: 3349| 4.42M| { 3350| 4.42M| const auto error_type_str = meta::keys[uint32_t(pe.ec)]; 3351| | 3352| 4.42M| const auto info = detail::get_source_info(buffer, pe.count); 3353| 4.42M| auto error_str = detail::generate_error_string(error_type_str, info); 3354| 4.42M| if (pe.custom_error_message.size()) { ------------------ | Branch (3354:11): [True: 0, False: 4.42M] ------------------ 3355| 0| error_str.append(" "); 3356| 0| error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end()); 3357| 0| } 3358| 4.42M| return error_str; 3359| 4.42M| } _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz5pointEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm1ELm1EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2503| 7.53k| { 2504| | if constexpr (HashInfo.sized_hash) { 2505| | const auto* c = quote_memchr(it, end); 2506| | if (c) [[likely]] { 2507| | const auto n = size_t(static_cast>(c) - it); 2508| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2509| | return N; // error 2510| | } 2511| | 2512| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2513| | return HashInfo.table[h % bsize]; 2514| | } 2515| | else [[unlikely]] { 2516| | return N; 2517| | } 2518| | } 2519| 7.53k| else { 2520| 7.53k| if constexpr (N == 2) { 2521| | if constexpr (uindex > 0) { 2522| | if (size_t(end - it) <= uindex) [[unlikely]] { 2523| | return N; // error 2524| | } 2525| | } 2526| | // Avoids using a hash table 2527| 7.53k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2528| 7.53k| return size_t(bool(it[uindex] ^ first_key_char)); 2529| | } 2530| | else { 2531| | if constexpr (uindex > 0) { 2532| | if (size_t(end - it) <= uindex) [[unlikely]] { 2533| | return N; // error 2534| | } 2535| | } 2536| | return HashInfo.table[uint8_t(it[uindex])]; 2537| | } 2538| 7.53k| } 2539| 7.53k| } _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz8fuzz_apiEXtlNS_11hash_info_tIS2_Lm128EEELNS_9hash_typeE2EtlNSt3__15arrayIhLm128EEEtlA128_hLh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh11ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh6ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh9ELh13ELh13ELh13ELh13ELh13ELh12ELh13ELh13ELh13ELh13ELh0ELh13ELh13ELh13ELh13ELh13ELh13ELh5ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh4ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh1ELh13ELh10ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh2ELh3ELh13ELh13ELh13ELh13ELh13ELh13ELh8ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh7ELh13ELh13ELh13ELh13ELh13ELh13ELh13EEELm4ELm8ELm15149911783463666029ELm18446744073709551615ELb0ELm2EEELS5_2EE2opIRPKcSD_EEmOT_T0_: 2568| 27.8k| { 2569| 27.8k| if constexpr (HashInfo.front_hash_bytes == 2) { 2570| 27.8k| if (size_t(end - it) <= 2) [[unlikely]] { ------------------ | Branch (2570:17): [True: 7, False: 27.8k] ------------------ 2571| 7| return N; // error 2572| 7| } 2573| 27.8k| uint16_t h; 2574| | if consteval { 2575| | h = 0; 2576| | for (size_t i = 0; i < 2; ++i) { 2577| | h |= static_cast(static_cast(it[i])) << (8 * i); 2578| | } 2579| | } 2580| 27.8k| else { 2581| 27.8k| std::memcpy(&h, it, 2); 2582| | if constexpr (std::endian::native == std::endian::big) { 2583| | h = std::byteswap(h); 2584| | } 2585| 27.8k| } 2586| 27.8k| return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2587| | } 2588| | else if constexpr (HashInfo.front_hash_bytes == 4) { 2589| | if (size_t(end - it) <= 4) [[unlikely]] { 2590| | return N; 2591| | } 2592| | uint32_t h; 2593| | if consteval { 2594| | h = 0; 2595| | for (size_t i = 0; i < 4; ++i) { 2596| | h |= static_cast(static_cast(it[i])) << (8 * i); 2597| | } 2598| | } 2599| | else { 2600| | std::memcpy(&h, it, 4); 2601| | if constexpr (std::endian::native == std::endian::big) { 2602| | h = std::byteswap(h); 2603| | } 2604| | } 2605| | return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2606| | } 2607| | else if constexpr (HashInfo.front_hash_bytes == 8) { 2608| | if (size_t(end - it) <= 8) [[unlikely]] { 2609| | return N; 2610| | } 2611| | uint64_t h; 2612| | if consteval { 2613| | h = 0; 2614| | for (size_t i = 0; i < 8; ++i) { 2615| | h |= static_cast(static_cast(it[i])) << (8 * i); 2616| | } 2617| | } 2618| | else { 2619| | std::memcpy(&h, it, 8); 2620| | if constexpr (std::endian::native == std::endian::big) { 2621| | h = std::byteswap(h); 2622| | } 2623| | } 2624| | return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize]; 2625| | } 2626| | else { 2627| | static_assert(false_v, "invalid hash algorithm"); 2628| | } 2629| 27.8k| } _ZN3glz6bitmixEmm: 1531| 27.8k| { 1532| 27.8k| h *= seed; 1533| 27.8k| return h ^ std::rotr(h, 49); 1534| 27.8k| }; _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz6nestedEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm5ELm5EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2503| 13.8k| { 2504| | if constexpr (HashInfo.sized_hash) { 2505| | const auto* c = quote_memchr(it, end); 2506| | if (c) [[likely]] { 2507| | const auto n = size_t(static_cast>(c) - it); 2508| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2509| | return N; // error 2510| | } 2511| | 2512| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2513| | return HashInfo.table[h % bsize]; 2514| | } 2515| | else [[unlikely]] { 2516| | return N; 2517| | } 2518| | } 2519| 13.8k| else { 2520| 13.8k| if constexpr (N == 2) { 2521| | if constexpr (uindex > 0) { 2522| | if (size_t(end - it) <= uindex) [[unlikely]] { 2523| | return N; // error 2524| | } 2525| | } 2526| | // Avoids using a hash table 2527| 13.8k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2528| 13.8k| return size_t(bool(it[uindex] ^ first_key_char)); 2529| | } 2530| | else { 2531| | if constexpr (uindex > 0) { 2532| | if (size_t(end - it) <= uindex) [[unlikely]] { 2533| | return N; // error 2534| | } 2535| | } 2536| | return HashInfo.table[uint8_t(it[uindex])]; 2537| | } 2538| 13.8k| } 2539| 13.8k| } _ZN3glz11decode_hashILj10ENS_3rpc18request_envelope_tEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh0ELh4ELh4ELh1ELh4ELh4ELh2ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm2ELm7EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2503| 268k| { 2504| | if constexpr (HashInfo.sized_hash) { 2505| | const auto* c = quote_memchr(it, end); 2506| | if (c) [[likely]] { 2507| | const auto n = size_t(static_cast>(c) - it); 2508| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2509| | return N; // error 2510| | } 2511| | 2512| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2513| | return HashInfo.table[h % bsize]; 2514| | } 2515| | else [[unlikely]] { 2516| | return N; 2517| | } 2518| | } 2519| 268k| else { 2520| | if constexpr (N == 2) { 2521| | if constexpr (uindex > 0) { 2522| | if (size_t(end - it) <= uindex) [[unlikely]] { 2523| | return N; // error 2524| | } 2525| | } 2526| | // Avoids using a hash table 2527| | constexpr auto first_key_char = reflect::keys[0][uindex]; 2528| | return size_t(bool(it[uindex] ^ first_key_char)); 2529| | } 2530| 268k| else { 2531| | if constexpr (uindex > 0) { 2532| | if (size_t(end - it) <= uindex) [[unlikely]] { 2533| | return N; // error 2534| | } 2535| | } 2536| 268k| return HashInfo.table[uint8_t(it[uindex])]; 2537| 268k| } 2538| 268k| } 2539| 268k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 116| 6.04k| { 117| 6.04k| using D = std::remove_cvref_t; 118| 6.04k| if constexpr (tuple_detail::is_tuple) { 119| 6.04k| static_assert(I < D::N, "glz::get index is out of range"); 120| 6.04k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 6.04k| else { 128| 6.04k| return static_cast(static_cast&>(tup).value); 129| 6.04k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 6.04k| } _ZN3glz3tieIJddEEENS_5tupleIJDpRT_EEES4_: 325| 74.5k| { 326| 74.5k| return {{{ts}...}}; 327| 74.5k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 116| 1.29k| { 117| 1.29k| using D = std::remove_cvref_t; 118| 1.29k| if constexpr (tuple_detail::is_tuple) { 119| 1.29k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.29k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 1.29k| else { 128| 1.29k| return static_cast(static_cast&>(tup).value); 129| 1.29k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.29k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 116| 67.1k| { 117| 67.1k| using D = std::remove_cvref_t; 118| 67.1k| if constexpr (tuple_detail::is_tuple) { 119| 67.1k| static_assert(I < D::N, "glz::get index is out of range"); 120| 67.1k| using T = typename D::template type_at; 121| 67.1k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 67.1k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 67.1k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 67.1k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 116| 67.1k| { 117| 67.1k| using D = std::remove_cvref_t; 118| 67.1k| if constexpr (tuple_detail::is_tuple) { 119| 67.1k| static_assert(I < D::N, "glz::get index is out of range"); 120| 67.1k| using T = typename D::template type_at; 121| 67.1k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 67.1k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 67.1k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 67.1k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 13.9k| { 117| 13.9k| using D = std::remove_cvref_t; 118| 13.9k| if constexpr (tuple_detail::is_tuple) { 119| 13.9k| static_assert(I < D::N, "glz::get index is out of range"); 120| 13.9k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 13.9k| else { 128| 13.9k| return static_cast(static_cast&>(tup).value); 129| 13.9k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 13.9k| } _ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz5pointENS8_6nestedENS1_6vectorIiNS5_IiEEEENS1_3mapIS7_iNS1_4lessIS7_EENS5_INS1_4pairIKS7_iEEEEEENS1_8optionalIdEENS1_7variantIJS7_NS8_6amountEEEENS1_8functionIFiiEEENSR_IFS7_RSI_EEENSR_IFS9_RKS9_EEENSR_IFdRNSB_IdNS5_IdEEEEEEENSR_IFvvEEEEEENS_5tupleIJDpRT_EEES1B_: 325| 93.8k| { 326| 93.8k| return {{{ts}...}}; 327| 93.8k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 204| { 117| 204| using D = std::remove_cvref_t; 118| 204| if constexpr (tuple_detail::is_tuple) { 119| 204| static_assert(I < D::N, "glz::get index is out of range"); 120| 204| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 204| else { 128| 204| return static_cast(static_cast&>(tup).value); 129| 204| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 204| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 680| { 117| 680| using D = std::remove_cvref_t; 118| 680| if constexpr (tuple_detail::is_tuple) { 119| 680| static_assert(I < D::N, "glz::get index is out of range"); 120| 680| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 680| else { 128| 680| return static_cast(static_cast&>(tup).value); 129| 680| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 680| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 12.8k| { 117| 12.8k| using D = std::remove_cvref_t; 118| 12.8k| if constexpr (tuple_detail::is_tuple) { 119| 12.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 12.8k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 12.8k| else { 128| 12.8k| return static_cast(static_cast&>(tup).value); 129| 12.8k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 12.8k| } _ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_5tupleIJDpRT_EEESB_: 325| 80.4k| { 326| 80.4k| return {{{ts}...}}; 327| 80.4k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 817| { 117| 817| using D = std::remove_cvref_t; 118| 817| if constexpr (tuple_detail::is_tuple) { 119| 817| static_assert(I < D::N, "glz::get index is out of range"); 120| 817| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 817| else { 128| 817| return static_cast(static_cast&>(tup).value); 129| 817| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 817| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 856| { 117| 856| using D = std::remove_cvref_t; 118| 856| if constexpr (tuple_detail::is_tuple) { 119| 856| static_assert(I < D::N, "glz::get index is out of range"); 120| 856| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 856| else { 128| 856| return static_cast(static_cast&>(tup).value); 129| 856| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 856| } _ZN3glz3getILm4ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 6.91k| { 117| 6.91k| using D = std::remove_cvref_t; 118| 6.91k| if constexpr (tuple_detail::is_tuple) { 119| 6.91k| static_assert(I < D::N, "glz::get index is out of range"); 120| 6.91k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 6.91k| else { 128| 6.91k| return static_cast(static_cast&>(tup).value); 129| 6.91k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 6.91k| } _ZN3glz3getILm5ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 1.17k| { 117| 1.17k| using D = std::remove_cvref_t; 118| 1.17k| if constexpr (tuple_detail::is_tuple) { 119| 1.17k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.17k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 1.17k| else { 128| 1.17k| return static_cast(static_cast&>(tup).value); 129| 1.17k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.17k| } _ZN3glz3getILm6ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 1.40k| { 117| 1.40k| using D = std::remove_cvref_t; 118| 1.40k| if constexpr (tuple_detail::is_tuple) { 119| 1.40k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.40k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 1.40k| else { 128| 1.40k| return static_cast(static_cast&>(tup).value); 129| 1.40k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.40k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdEEEEEDcOT0_: 116| 315| { 117| 315| using D = std::remove_cvref_t; 118| 315| if constexpr (tuple_detail::is_tuple) { 119| 315| static_assert(I < D::N, "glz::get index is out of range"); 120| 315| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 315| else { 128| 315| return static_cast(static_cast&>(tup).value); 129| 315| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 315| } _ZN3glz3tieIJdEEENS_5tupleIJDpRT_EEES4_: 325| 315| { 326| 315| return {{{ts}...}}; 327| 315| } _ZN3glz3getILm7ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 1.19k| { 117| 1.19k| using D = std::remove_cvref_t; 118| 1.19k| if constexpr (tuple_detail::is_tuple) { 119| 1.19k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.19k| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 1.19k| else { 128| 1.19k| return static_cast(static_cast&>(tup).value); 129| 1.19k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.19k| } _ZN3glz3getILm8ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 241| { 117| 241| using D = std::remove_cvref_t; 118| 241| if constexpr (tuple_detail::is_tuple) { 119| 241| static_assert(I < D::N, "glz::get index is out of range"); 120| 241| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 241| else { 128| 241| return static_cast(static_cast&>(tup).value); 129| 241| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 241| } _ZN3glz3getILm9ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 241| { 117| 241| using D = std::remove_cvref_t; 118| 241| if constexpr (tuple_detail::is_tuple) { 119| 241| static_assert(I < D::N, "glz::get index is out of range"); 120| 241| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 241| else { 128| 241| return static_cast(static_cast&>(tup).value); 129| 241| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 241| } _ZN3glz3getILm10ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 52| { 117| 52| using D = std::remove_cvref_t; 118| 52| if constexpr (tuple_detail::is_tuple) { 119| 52| static_assert(I < D::N, "glz::get index is out of range"); 120| 52| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 52| else { 128| 52| return static_cast(static_cast&>(tup).value); 129| 52| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 52| } _ZN3glz3getILm11ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 49| { 117| 49| using D = std::remove_cvref_t; 118| 49| if constexpr (tuple_detail::is_tuple) { 119| 49| static_assert(I < D::N, "glz::get index is out of range"); 120| 49| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 49| else { 128| 49| return static_cast(static_cast&>(tup).value); 129| 49| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 49| } _ZN3glz3getILm12ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 120| { 117| 120| using D = std::remove_cvref_t; 118| 120| if constexpr (tuple_detail::is_tuple) { 119| 120| static_assert(I < D::N, "glz::get index is out of range"); 120| 120| using T = typename D::template type_at; 121| | if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| | using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| | return (static_cast(tup).value); 126| | } 127| 120| else { 128| 120| return static_cast(static_cast&>(tup).value); 129| 120| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 120| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 66.8k| { 117| 66.8k| using D = std::remove_cvref_t; 118| 66.8k| if constexpr (tuple_detail::is_tuple) { 119| 66.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.8k| using T = typename D::template type_at; 121| 66.8k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.8k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.8k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 66.8k| { 117| 66.8k| using D = std::remove_cvref_t; 118| 66.8k| if constexpr (tuple_detail::is_tuple) { 119| 66.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.8k| using T = typename D::template type_at; 121| 66.8k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.8k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.8k| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm4ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm5ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm6ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm7ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm8ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm9ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm10ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm11ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm12ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN12jsonrpc_fuzz5pointERNSC_6nestedERNS4_6vectorIiNS8_IiEEEERNS4_3mapISA_iNS4_4lessISA_EENS8_INS4_4pairIKSA_iEEEEEERNS4_8optionalIdEERNS4_7variantIJSA_NSC_6amountEEEERNS4_8functionIFiiEEERNS11_IFSA_RSP_EEERNS11_IFSD_RKSD_EEERNS11_IFdRNSH_IdNS8_IdEEEEEEERNS11_IFvvEEEEEEEEDcOT0_: 116| 66.7k| { 117| 66.7k| using D = std::remove_cvref_t; 118| 66.7k| if constexpr (tuple_detail::is_tuple) { 119| 66.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 66.7k| using T = typename D::template type_at; 121| 66.7k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 66.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 66.7k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 66.7k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 64.4k| { 117| 64.4k| using D = std::remove_cvref_t; 118| 64.4k| if constexpr (tuple_detail::is_tuple) { 119| 64.4k| static_assert(I < D::N, "glz::get index is out of range"); 120| 64.4k| using T = typename D::template type_at; 121| 64.4k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 64.4k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 64.4k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 64.4k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 55.4k| { 117| 55.4k| using D = std::remove_cvref_t; 118| 55.4k| if constexpr (tuple_detail::is_tuple) { 119| 55.4k| static_assert(I < D::N, "glz::get index is out of range"); 120| 55.4k| using T = typename D::template type_at; 121| 55.4k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 55.4k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 55.4k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 55.4k| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 39.3k| { 117| 39.3k| using D = std::remove_cvref_t; 118| 39.3k| if constexpr (tuple_detail::is_tuple) { 119| 39.3k| static_assert(I < D::N, "glz::get index is out of range"); 120| 39.3k| using T = typename D::template type_at; 121| 39.3k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 39.3k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 39.3k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 39.3k| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 79.4k| { 117| 79.4k| using D = std::remove_cvref_t; 118| 79.4k| if constexpr (tuple_detail::is_tuple) { 119| 79.4k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.4k| using T = typename D::template type_at; 121| 79.4k| if constexpr (std::is_reference_v || std::is_const_v>) { 122| | // An lvalue, or a const tuple of either value category: element access carries the 123| | // constness of the tuple, except for elements that are themselves references. 124| 79.4k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.4k| return (static_cast(tup).value); 126| | } 127| | else { 128| | return static_cast(static_cast&>(tup).value); 129| | } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 79.4k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOSB_: 86| 47.1k| { 87| 47.1k| std::string buffer{}; 88| 47.1k| context ctx{}; 89| 47.1k| const auto res = write(std::forward(value), buffer, ctx); 90| 47.1k| if (res) [[unlikely]] { ------------------ | Branch (90:11): [True: 0, False: 47.1k] ------------------ 91| 0| return glz::unexpected(res); 92| 0| } 93| 47.1k| return {buffer}; 94| 47.1k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_: 18| 47.1k| { 19| 47.1k| using traits = buffer_traits>; 20| | 21| 47.1k| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 47.1k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 47.1k, False: 0] ------------------ 24| 47.1k| buffer.resize(2 * write_padding_bytes); 25| 47.1k| } 26| 47.1k| } 27| 47.1k| size_t ix = 0; // overwrite index 28| 47.1k| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 47.1k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 47.1k] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 47.1k| traits::finalize(buffer, ix); 35| 47.1k| return {ix, error_code::none, ctx.custom_error_message}; 36| 47.1k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOSA_: 86| 44.4k| { 87| 44.4k| std::string buffer{}; 88| 44.4k| context ctx{}; 89| 44.4k| const auto res = write(std::forward(value), buffer, ctx); 90| 44.4k| if (res) [[unlikely]] { ------------------ | Branch (90:11): [True: 0, False: 44.4k] ------------------ 91| 0| return glz::unexpected(res); 92| 0| } 93| 44.4k| return {buffer}; 94| 44.4k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEETkNS_13output_bufferENS2_12basic_stringIcS6_NS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_: 18| 44.4k| { 19| 44.4k| using traits = buffer_traits>; 20| | 21| 44.4k| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44.4k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44.4k, False: 0] ------------------ 24| 44.4k| buffer.resize(2 * write_padding_bytes); 25| 44.4k| } 26| 44.4k| } 27| 44.4k| size_t ix = 0; // overwrite index 28| 44.4k| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44.4k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44.4k] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44.4k| traits::finalize(buffer, ix); 35| 44.4k| return {ix, error_code::none, ctx.custom_error_message}; 36| 44.4k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 370| { 79| 370| context ctx{}; 80| 370| return write(std::forward(value), buffer, ctx); 81| 370| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 370| { 19| 370| using traits = buffer_traits>; 20| | 21| 370| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 370| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 370, False: 0] ------------------ 24| 370| buffer.resize(2 * write_padding_bytes); 25| 370| } 26| 370| } 27| 370| size_t ix = 0; // overwrite index 28| 370| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 370| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 370] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 370| traits::finalize(buffer, ix); 35| 370| return {ix, error_code::none, ctx.custom_error_message}; 36| 370| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_: 78| 311| { 79| 311| context ctx{}; 80| 311| return write(std::forward(value), buffer, ctx); 81| 311| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 311| { 19| 311| using traits = buffer_traits>; 20| | 21| 311| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 311| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 311, False: 0] ------------------ 24| 311| buffer.resize(2 * write_padding_bytes); 25| 311| } 26| 311| } 27| 311| size_t ix = 0; // overwrite index 28| 311| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 311| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 311] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 311| traits::finalize(buffer, ix); 35| 311| return {ix, error_code::none, ctx.custom_error_message}; 36| 311| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_: 78| 158| { 79| 158| context ctx{}; 80| 158| return write(std::forward(value), buffer, ctx); 81| 158| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_: 18| 158| { 19| 158| using traits = buffer_traits>; 20| | 21| 158| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 158| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 158, False: 0] ------------------ 24| 158| buffer.resize(2 * write_padding_bytes); 25| 158| } 26| 158| } 27| 158| size_t ix = 0; // overwrite index 28| 158| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 158| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 158] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 158| traits::finalize(buffer, ix); 35| 158| return {ix, error_code::none, ctx.custom_error_message}; 36| 158| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 50| { 79| 50| context ctx{}; 80| 50| return write(std::forward(value), buffer, ctx); 81| 50| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 50| { 19| 50| using traits = buffer_traits>; 20| | 21| 50| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 50| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 50, False: 0] ------------------ 24| 50| buffer.resize(2 * write_padding_bytes); 25| 50| } 26| 50| } 27| 50| size_t ix = 0; // overwrite index 28| 50| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 50| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 50] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 50| traits::finalize(buffer, ix); 35| 50| return {ix, error_code::none, ctx.custom_error_message}; 36| 50| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 654| { 79| 654| context ctx{}; 80| 654| return write(std::forward(value), buffer, ctx); 81| 654| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 654| { 19| 654| using traits = buffer_traits>; 20| | 21| 654| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 654| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 654, False: 0] ------------------ 24| 654| buffer.resize(2 * write_padding_bytes); 25| 654| } 26| 654| } 27| 654| size_t ix = 0; // overwrite index 28| 654| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 654| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 654] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 654| traits::finalize(buffer, ix); 35| 654| return {ix, error_code::none, ctx.custom_error_message}; 36| 654| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 1.91k| { 79| 1.91k| context ctx{}; 80| 1.91k| return write(std::forward(value), buffer, ctx); 81| 1.91k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 1.91k| { 19| 1.91k| using traits = buffer_traits>; 20| | 21| 1.91k| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 1.91k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 1.91k, False: 0] ------------------ 24| 1.91k| buffer.resize(2 * write_padding_bytes); 25| 1.91k| } 26| 1.91k| } 27| 1.91k| size_t ix = 0; // overwrite index 28| 1.91k| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 1.91k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 1.91k] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 1.91k| traits::finalize(buffer, ix); 35| 1.91k| return {ix, error_code::none, ctx.custom_error_message}; 36| 1.91k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 247| { 79| 247| context ctx{}; 80| 247| return write(std::forward(value), buffer, ctx); 81| 247| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 247| { 19| 247| using traits = buffer_traits>; 20| | 21| 247| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 247| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 247, False: 0] ------------------ 24| 247| buffer.resize(2 * write_padding_bytes); 25| 247| } 26| 247| } 27| 247| size_t ix = 0; // overwrite index 28| 247| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 247| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 247] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 247| traits::finalize(buffer, ix); 35| 247| return {ix, error_code::none, ctx.custom_error_message}; 36| 247| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 73| { 79| 73| context ctx{}; 80| 73| return write(std::forward(value), buffer, ctx); 81| 73| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 73| { 19| 73| using traits = buffer_traits>; 20| | 21| 73| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 73| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 73, False: 0] ------------------ 24| 73| buffer.resize(2 * write_padding_bytes); 25| 73| } 26| 73| } 27| 73| size_t ix = 0; // overwrite index 28| 73| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 73| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 73] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 73| traits::finalize(buffer, ix); 35| 73| return {ix, error_code::none, ctx.custom_error_message}; 36| 73| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_: 78| 125| { 79| 125| context ctx{}; 80| 125| return write(std::forward(value), buffer, ctx); 81| 125| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_: 18| 125| { 19| 125| using traits = buffer_traits>; 20| | 21| 125| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 125| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 125, False: 0] ------------------ 24| 125| buffer.resize(2 * write_padding_bytes); 25| 125| } 26| 125| } 27| 125| size_t ix = 0; // overwrite index 28| 125| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 125| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 125] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 125| traits::finalize(buffer, ix); 35| 125| return {ix, error_code::none, ctx.custom_error_message}; 36| 125| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSI_RT1_: 78| 53| { 79| 53| context ctx{}; 80| 53| return write(std::forward(value), buffer, ctx); 81| 53| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSK_RT1_OT2_: 18| 53| { 19| 53| using traits = buffer_traits>; 20| | 21| 53| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 53| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 53, False: 0] ------------------ 24| 53| buffer.resize(2 * write_padding_bytes); 25| 53| } 26| 53| } 27| 53| size_t ix = 0; // overwrite index 28| 53| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 53| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 53] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 53| traits::finalize(buffer, ix); 35| 53| return {ix, error_code::none, ctx.custom_error_message}; 36| 53| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 48| { 79| 48| context ctx{}; 80| 48| return write(std::forward(value), buffer, ctx); 81| 48| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 48| { 19| 48| using traits = buffer_traits>; 20| | 21| 48| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 48| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 48, False: 0] ------------------ 24| 48| buffer.resize(2 * write_padding_bytes); 25| 48| } 26| 48| } 27| 48| size_t ix = 0; // overwrite index 28| 48| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 48| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 48] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 48| traits::finalize(buffer, ix); 35| 48| return {ix, error_code::none, ctx.custom_error_message}; 36| 48| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_: 78| 73| { 79| 73| context ctx{}; 80| 73| return write(std::forward(value), buffer, ctx); 81| 73| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_: 18| 73| { 19| 73| using traits = buffer_traits>; 20| | 21| 73| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 73| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 73, False: 0] ------------------ 24| 73| buffer.resize(2 * write_padding_bytes); 25| 73| } 26| 73| } 27| 73| size_t ix = 0; // overwrite index 28| 73| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 73| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 73] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 73| traits::finalize(buffer, ix); 35| 73| return {ix, error_code::none, ctx.custom_error_message}; 36| 73| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOS9_: 86| 4.41M| { 87| 4.41M| std::string buffer{}; 88| 4.41M| context ctx{}; 89| 4.41M| const auto res = write(std::forward(value), buffer, ctx); 90| 4.41M| if (res) [[unlikely]] { ------------------ | Branch (90:11): [True: 0, False: 4.41M] ------------------ 91| 0| return glz::unexpected(res); 92| 0| } 93| 4.41M| return {buffer}; 94| 4.41M| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 4.41M| { 19| 4.41M| using traits = buffer_traits>; 20| | 21| 4.41M| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 4.41M| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 4.41M, False: 0] ------------------ 24| 4.41M| buffer.resize(2 * write_padding_bytes); 25| 4.41M| } 26| 4.41M| } 27| 4.41M| size_t ix = 0; // overwrite index 28| 4.41M| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 4.41M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 4.41M] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 4.41M| traits::finalize(buffer, ix); 35| 4.41M| return {ix, error_code::none, ctx.custom_error_message}; 36| 4.41M| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOS9_: 86| 37| { 87| 37| std::string buffer{}; 88| 37| context ctx{}; 89| 37| const auto res = write(std::forward(value), buffer, ctx); 90| 37| if (res) [[unlikely]] { ------------------ | Branch (90:11): [True: 0, False: 37] ------------------ 91| 0| return glz::unexpected(res); 92| 0| } 93| 37| return {buffer}; 94| 37| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_13output_bufferENS2_12basic_stringIcS5_NS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_: 18| 37| { 19| 37| using traits = buffer_traits>; 20| | 21| 37| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 37| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 37, False: 0] ------------------ 24| 37| buffer.resize(2 * write_padding_bytes); 25| 37| } 26| 37| } 27| 37| size_t ix = 0; // overwrite index 28| 37| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 37| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 37] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 37| traits::finalize(buffer, ix); 35| 37| return {ix, error_code::none, ctx.custom_error_message}; 36| 37| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 30.9k| { 206| | /*if constexpr (std::same_as, std::string>) { 207| | // more efficient strings in C++23: 208| | https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite 209| | }*/ 210| | 211| | // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value 212| | // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t 213| | if constexpr (resizable && not check_write_unchecked(Opts)) { 214| | if (const auto k = ix + 64; k > b.size()) { 215| | grow_buffer(b, k); 216| | } 217| | } 218| | 219| 30.9k| using V = std::decay_t; 220| | 221| | if constexpr (std::floating_point) { 222| | using opts_type = std::decay_t; 223| | constexpr bool use_float_format = requires { opts_type::float_format; }; 224| | 225| | // User-specified float_format takes priority over all other options 226| | if constexpr (use_float_format && is_any_of) { 227| |#if GLZ_USE_STD_FORMAT_FLOAT 228| | // Use std::format with user-provided format string (e.g., "{:.2f}") 229| | // Format string is validated at compile-time via std::format_string 230| | constexpr auto fmt = std::format_string{opts_type::float_format}; 231| | 232| | if constexpr (check_write_unchecked(Opts)) { 233| | // Caller guarantees buffer has enough space 234| | const auto start = reinterpret_cast(&b[ix]); 235| | auto result = std::format_to(start, fmt, V(value)); 236| | ix += size_t(result - start); 237| | } 238| | else { 239| | // format_to_n writes up to 'available' chars and returns total size needed. 240| | // Common case: output fits in pre-allocated buffer (single pass). 241| | // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize. 242| | const auto start = reinterpret_cast(&b[ix]); 243| | const auto available = b.size() - ix; 244| | auto [out, size] = std::format_to_n(start, available, fmt, V(value)); 245| | 246| | if (static_cast(size) > available) { 247| | // Output was truncated - size tells us exactly how much space we need 248| | if constexpr (resizable) { 249| | grow_buffer(b, ix + size); 250| | std::format_to(reinterpret_cast(&b[ix]), fmt, V(value)); 251| | } 252| | else { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | ix += size; 258| | } 259| |#else 260| | // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3) 261| | // Convert std::format spec to printf format at compile time 262| | constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format); 263| | 264| | const auto start = reinterpret_cast(&b[ix]); 265| | const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix); 266| | 267| | // snprintf returns chars that would be written (excluding null), or negative on error 268| | const int len = std::snprintf(start, available, printf_fmt.data, static_cast(value)); 269| | 270| | if (len < 0) { 271| | ctx.error = error_code::unexpected_end; 272| | return; 273| | } 274| | 275| | if (static_cast(len) >= available) { 276| | // Output was truncated, need to resize and retry 277| | if constexpr (resizable && not check_write_unchecked(Opts)) { 278| | grow_buffer(b, ix + static_cast(len) + 1); 279| | std::snprintf(reinterpret_cast(&b[ix]), static_cast(len) + 1, printf_fmt.data, 280| | static_cast(value)); 281| | } 282| | else { 283| | ctx.error = error_code::unexpected_end; 284| | return; 285| | } 286| | } 287| | ix += static_cast(len); 288| |#endif 289| | } 290| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 && 291| | uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) { 292| | // we cast to a lower precision floating point value before writing out 293| | if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) { 294| | const auto reduced = static_cast(value); 295| | const auto start = reinterpret_cast(&b[ix]); 296| | const auto end = glz::to_chars(start, reduced); 297| | ix += size_t(end - start); 298| | } 299| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) { 300| | const auto reduced = static_cast(value); 301| | const auto start = reinterpret_cast(&b[ix]); 302| | const auto end = glz::to_chars(start, reduced); 303| | ix += size_t(end - start); 304| | } 305| | else { 306| | static_assert(false_v, "invalid float_max_write_precision"); 307| | } 308| | } 309| | // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup 310| | // tables are dropped (recomputed on the fly). Much faster than the 311| | // old simple_float::to_chars path at essentially the same footprint. 312| | // See discussion #2519. 313| | else if constexpr (is_size_optimized(Opts) && is_any_of) { 314| | const auto start = reinterpret_cast(&b[ix]); 315| | const auto end = glz::to_chars(start, V(value)); 316| | ix += size_t(end - start); 317| | } 318| | else if constexpr (is_any_of) { 319| | const auto start = reinterpret_cast(&b[ix]); 320| | const auto end = glz::to_chars(start, value); 321| | ix += size_t(end - start); 322| | } 323| |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 324| |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT 325| | else if constexpr (is_float128) { 326| | const auto start = reinterpret_cast(&b[ix]); 327| | const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general); 328| | if (ec != std::errc()) { 329| | ctx.error = error_code::unexpected_end; 330| | return; 331| | } 332| | ix += size_t(ptr - start); 333| | } 334| |#endif 335| | else { 336| | static_assert(false_v, "type is not supported"); 337| | } 338| | } 339| | else if constexpr (is_any_of) { 340| | // Small integers: always use to_chars (400B tables) 341| | // The 40KB digit_quads table doesn't help for these small ranges 342| | const auto start = reinterpret_cast(&b[ix]); 343| | const auto end = glz::to_chars(start, value); 344| | ix += size_t(end - start); 345| | } 346| 30.9k| else if constexpr (is_any_of) { 347| 30.9k| const auto start = reinterpret_cast(&b[ix]); 348| | if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| | const auto end = glz::to_chars(start, value); 351| | ix += size_t(end - start); 352| | } 353| 30.9k| else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| 30.9k| const auto end = glz::to_chars_40kb(start, value); 356| 30.9k| ix += size_t(end - start); 357| 30.9k| } 358| | } 359| | else if constexpr (std::integral) { 360| | // Handle other integral types (char, wchar_t, etc.) by casting to sized types 361| | using X = std::decay_t())>; 362| | const auto start = reinterpret_cast(&b[ix]); 363| | if constexpr (is_size_optimized(Opts)) { 364| | // Size mode: use glz::to_chars (400B lookup tables) 365| | const auto end = glz::to_chars(start, static_cast(value)); 366| | ix += size_t(end - start); 367| | } 368| | else { 369| | // Normal mode: use to_chars_40kb 370| | const auto end = glz::to_chars_40kb(start, static_cast(value)); 371| | ix += size_t(end - start); 372| | } 373| | } 374| | else { 375| | static_assert(false_v, "type is not supported"); 376| | } 377| 30.9k| } _ZN3glz11write_chars2opITnDaXtlNS_9opts_sizeEtlNS_4optsELj10ELb1ELb0ELb1ELb1EEEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_5num_tERKmTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 4.76M| { 206| | /*if constexpr (std::same_as, std::string>) { 207| | // more efficient strings in C++23: 208| | https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite 209| | }*/ 210| | 211| | // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value 212| | // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t 213| 4.76M| if constexpr (resizable && not check_write_unchecked(Opts)) { 214| 4.76M| if (const auto k = ix + 64; k > b.size()) { ------------------ | Branch (214:41): [True: 0, False: 4.76M] ------------------ 215| 0| grow_buffer(b, k); 216| 0| } 217| 4.76M| } 218| | 219| 4.76M| using V = std::decay_t; 220| | 221| | if constexpr (std::floating_point) { 222| | using opts_type = std::decay_t; 223| | constexpr bool use_float_format = requires { opts_type::float_format; }; 224| | 225| | // User-specified float_format takes priority over all other options 226| | if constexpr (use_float_format && is_any_of) { 227| |#if GLZ_USE_STD_FORMAT_FLOAT 228| | // Use std::format with user-provided format string (e.g., "{:.2f}") 229| | // Format string is validated at compile-time via std::format_string 230| | constexpr auto fmt = std::format_string{opts_type::float_format}; 231| | 232| | if constexpr (check_write_unchecked(Opts)) { 233| | // Caller guarantees buffer has enough space 234| | const auto start = reinterpret_cast(&b[ix]); 235| | auto result = std::format_to(start, fmt, V(value)); 236| | ix += size_t(result - start); 237| | } 238| | else { 239| | // format_to_n writes up to 'available' chars and returns total size needed. 240| | // Common case: output fits in pre-allocated buffer (single pass). 241| | // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize. 242| | const auto start = reinterpret_cast(&b[ix]); 243| | const auto available = b.size() - ix; 244| | auto [out, size] = std::format_to_n(start, available, fmt, V(value)); 245| | 246| | if (static_cast(size) > available) { 247| | // Output was truncated - size tells us exactly how much space we need 248| | if constexpr (resizable) { 249| | grow_buffer(b, ix + size); 250| | std::format_to(reinterpret_cast(&b[ix]), fmt, V(value)); 251| | } 252| | else { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | ix += size; 258| | } 259| |#else 260| | // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3) 261| | // Convert std::format spec to printf format at compile time 262| | constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format); 263| | 264| | const auto start = reinterpret_cast(&b[ix]); 265| | const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix); 266| | 267| | // snprintf returns chars that would be written (excluding null), or negative on error 268| | const int len = std::snprintf(start, available, printf_fmt.data, static_cast(value)); 269| | 270| | if (len < 0) { 271| | ctx.error = error_code::unexpected_end; 272| | return; 273| | } 274| | 275| | if (static_cast(len) >= available) { 276| | // Output was truncated, need to resize and retry 277| | if constexpr (resizable && not check_write_unchecked(Opts)) { 278| | grow_buffer(b, ix + static_cast(len) + 1); 279| | std::snprintf(reinterpret_cast(&b[ix]), static_cast(len) + 1, printf_fmt.data, 280| | static_cast(value)); 281| | } 282| | else { 283| | ctx.error = error_code::unexpected_end; 284| | return; 285| | } 286| | } 287| | ix += static_cast(len); 288| |#endif 289| | } 290| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 && 291| | uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) { 292| | // we cast to a lower precision floating point value before writing out 293| | if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) { 294| | const auto reduced = static_cast(value); 295| | const auto start = reinterpret_cast(&b[ix]); 296| | const auto end = glz::to_chars(start, reduced); 297| | ix += size_t(end - start); 298| | } 299| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) { 300| | const auto reduced = static_cast(value); 301| | const auto start = reinterpret_cast(&b[ix]); 302| | const auto end = glz::to_chars(start, reduced); 303| | ix += size_t(end - start); 304| | } 305| | else { 306| | static_assert(false_v, "invalid float_max_write_precision"); 307| | } 308| | } 309| | // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup 310| | // tables are dropped (recomputed on the fly). Much faster than the 311| | // old simple_float::to_chars path at essentially the same footprint. 312| | // See discussion #2519. 313| | else if constexpr (is_size_optimized(Opts) && is_any_of) { 314| | const auto start = reinterpret_cast(&b[ix]); 315| | const auto end = glz::to_chars(start, V(value)); 316| | ix += size_t(end - start); 317| | } 318| | else if constexpr (is_any_of) { 319| | const auto start = reinterpret_cast(&b[ix]); 320| | const auto end = glz::to_chars(start, value); 321| | ix += size_t(end - start); 322| | } 323| |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 324| |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT 325| | else if constexpr (is_float128) { 326| | const auto start = reinterpret_cast(&b[ix]); 327| | const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general); 328| | if (ec != std::errc()) { 329| | ctx.error = error_code::unexpected_end; 330| | return; 331| | } 332| | ix += size_t(ptr - start); 333| | } 334| |#endif 335| | else { 336| | static_assert(false_v, "type is not supported"); 337| | } 338| | } 339| | else if constexpr (is_any_of) { 340| | // Small integers: always use to_chars (400B tables) 341| | // The 40KB digit_quads table doesn't help for these small ranges 342| | const auto start = reinterpret_cast(&b[ix]); 343| | const auto end = glz::to_chars(start, value); 344| | ix += size_t(end - start); 345| | } 346| 4.76M| else if constexpr (is_any_of) { 347| 4.76M| const auto start = reinterpret_cast(&b[ix]); 348| 4.76M| if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| 4.76M| const auto end = glz::to_chars(start, value); 351| 4.76M| ix += size_t(end - start); 352| | } 353| | else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| | const auto end = glz::to_chars_40kb(start, value); 356| | ix += size_t(end - start); 357| | } 358| | } 359| | else if constexpr (std::integral) { 360| | // Handle other integral types (char, wchar_t, etc.) by casting to sized types 361| | using X = std::decay_t())>; 362| | const auto start = reinterpret_cast(&b[ix]); 363| | if constexpr (is_size_optimized(Opts)) { 364| | // Size mode: use glz::to_chars (400B lookup tables) 365| | const auto end = glz::to_chars(start, static_cast(value)); 366| | ix += size_t(end - start); 367| | } 368| | else { 369| | // Normal mode: use to_chars_40kb 370| | const auto end = glz::to_chars_40kb(start, static_cast(value)); 371| | ix += size_t(end - start); 372| | } 373| | } 374| | else { 375| | static_assert(false_v, "type is not supported"); 376| | } 377| 4.76M| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 854| { 206| | /*if constexpr (std::same_as, std::string>) { 207| | // more efficient strings in C++23: 208| | https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite 209| | }*/ 210| | 211| | // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value 212| | // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t 213| | if constexpr (resizable && not check_write_unchecked(Opts)) { 214| | if (const auto k = ix + 64; k > b.size()) { 215| | grow_buffer(b, k); 216| | } 217| | } 218| | 219| 854| using V = std::decay_t; 220| | 221| | if constexpr (std::floating_point) { 222| | using opts_type = std::decay_t; 223| | constexpr bool use_float_format = requires { opts_type::float_format; }; 224| | 225| | // User-specified float_format takes priority over all other options 226| | if constexpr (use_float_format && is_any_of) { 227| |#if GLZ_USE_STD_FORMAT_FLOAT 228| | // Use std::format with user-provided format string (e.g., "{:.2f}") 229| | // Format string is validated at compile-time via std::format_string 230| | constexpr auto fmt = std::format_string{opts_type::float_format}; 231| | 232| | if constexpr (check_write_unchecked(Opts)) { 233| | // Caller guarantees buffer has enough space 234| | const auto start = reinterpret_cast(&b[ix]); 235| | auto result = std::format_to(start, fmt, V(value)); 236| | ix += size_t(result - start); 237| | } 238| | else { 239| | // format_to_n writes up to 'available' chars and returns total size needed. 240| | // Common case: output fits in pre-allocated buffer (single pass). 241| | // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize. 242| | const auto start = reinterpret_cast(&b[ix]); 243| | const auto available = b.size() - ix; 244| | auto [out, size] = std::format_to_n(start, available, fmt, V(value)); 245| | 246| | if (static_cast(size) > available) { 247| | // Output was truncated - size tells us exactly how much space we need 248| | if constexpr (resizable) { 249| | grow_buffer(b, ix + size); 250| | std::format_to(reinterpret_cast(&b[ix]), fmt, V(value)); 251| | } 252| | else { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | ix += size; 258| | } 259| |#else 260| | // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3) 261| | // Convert std::format spec to printf format at compile time 262| | constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format); 263| | 264| | const auto start = reinterpret_cast(&b[ix]); 265| | const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix); 266| | 267| | // snprintf returns chars that would be written (excluding null), or negative on error 268| | const int len = std::snprintf(start, available, printf_fmt.data, static_cast(value)); 269| | 270| | if (len < 0) { 271| | ctx.error = error_code::unexpected_end; 272| | return; 273| | } 274| | 275| | if (static_cast(len) >= available) { 276| | // Output was truncated, need to resize and retry 277| | if constexpr (resizable && not check_write_unchecked(Opts)) { 278| | grow_buffer(b, ix + static_cast(len) + 1); 279| | std::snprintf(reinterpret_cast(&b[ix]), static_cast(len) + 1, printf_fmt.data, 280| | static_cast(value)); 281| | } 282| | else { 283| | ctx.error = error_code::unexpected_end; 284| | return; 285| | } 286| | } 287| | ix += static_cast(len); 288| |#endif 289| | } 290| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 && 291| | uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) { 292| | // we cast to a lower precision floating point value before writing out 293| | if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) { 294| | const auto reduced = static_cast(value); 295| | const auto start = reinterpret_cast(&b[ix]); 296| | const auto end = glz::to_chars(start, reduced); 297| | ix += size_t(end - start); 298| | } 299| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) { 300| | const auto reduced = static_cast(value); 301| | const auto start = reinterpret_cast(&b[ix]); 302| | const auto end = glz::to_chars(start, reduced); 303| | ix += size_t(end - start); 304| | } 305| | else { 306| | static_assert(false_v, "invalid float_max_write_precision"); 307| | } 308| | } 309| | // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup 310| | // tables are dropped (recomputed on the fly). Much faster than the 311| | // old simple_float::to_chars path at essentially the same footprint. 312| | // See discussion #2519. 313| | else if constexpr (is_size_optimized(Opts) && is_any_of) { 314| | const auto start = reinterpret_cast(&b[ix]); 315| | const auto end = glz::to_chars(start, V(value)); 316| | ix += size_t(end - start); 317| | } 318| | else if constexpr (is_any_of) { 319| | const auto start = reinterpret_cast(&b[ix]); 320| | const auto end = glz::to_chars(start, value); 321| | ix += size_t(end - start); 322| | } 323| |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 324| |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT 325| | else if constexpr (is_float128) { 326| | const auto start = reinterpret_cast(&b[ix]); 327| | const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general); 328| | if (ec != std::errc()) { 329| | ctx.error = error_code::unexpected_end; 330| | return; 331| | } 332| | ix += size_t(ptr - start); 333| | } 334| |#endif 335| | else { 336| | static_assert(false_v, "type is not supported"); 337| | } 338| | } 339| | else if constexpr (is_any_of) { 340| | // Small integers: always use to_chars (400B tables) 341| | // The 40KB digit_quads table doesn't help for these small ranges 342| | const auto start = reinterpret_cast(&b[ix]); 343| | const auto end = glz::to_chars(start, value); 344| | ix += size_t(end - start); 345| | } 346| 854| else if constexpr (is_any_of) { 347| 854| const auto start = reinterpret_cast(&b[ix]); 348| | if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| | const auto end = glz::to_chars(start, value); 351| | ix += size_t(end - start); 352| | } 353| 854| else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| 854| const auto end = glz::to_chars_40kb(start, value); 356| 854| ix += size_t(end - start); 357| 854| } 358| | } 359| | else if constexpr (std::integral) { 360| | // Handle other integral types (char, wchar_t, etc.) by casting to sized types 361| | using X = std::decay_t())>; 362| | const auto start = reinterpret_cast(&b[ix]); 363| | if constexpr (is_size_optimized(Opts)) { 364| | // Size mode: use glz::to_chars (400B lookup tables) 365| | const auto end = glz::to_chars(start, static_cast(value)); 366| | ix += size_t(end - start); 367| | } 368| | else { 369| | // Normal mode: use to_chars_40kb 370| | const auto end = glz::to_chars_40kb(start, static_cast(value)); 371| | ix += size_t(end - start); 372| | } 373| | } 374| | else { 375| | static_assert(false_v, "type is not supported"); 376| | } 377| 854| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 2.82k| { 206| | /*if constexpr (std::same_as, std::string>) { 207| | // more efficient strings in C++23: 208| | https://en.cppreference.com/w/cpp/string/basic_string/resize_and_overwrite 209| | }*/ 210| | 211| | // https://stackoverflow.com/questions/1701055/what-is-the-maximum-length-in-chars-needed-to-represent-any-double-value 212| | // maximum length for a double should be 24 chars, we use 64 to be sufficient for float128_t 213| | if constexpr (resizable && not check_write_unchecked(Opts)) { 214| | if (const auto k = ix + 64; k > b.size()) { 215| | grow_buffer(b, k); 216| | } 217| | } 218| | 219| 2.82k| using V = std::decay_t; 220| | 221| 2.82k| if constexpr (std::floating_point) { 222| 2.82k| using opts_type = std::decay_t; 223| 2.82k| constexpr bool use_float_format = requires { opts_type::float_format; }; 224| | 225| | // User-specified float_format takes priority over all other options 226| | if constexpr (use_float_format && is_any_of) { 227| |#if GLZ_USE_STD_FORMAT_FLOAT 228| | // Use std::format with user-provided format string (e.g., "{:.2f}") 229| | // Format string is validated at compile-time via std::format_string 230| | constexpr auto fmt = std::format_string{opts_type::float_format}; 231| | 232| | if constexpr (check_write_unchecked(Opts)) { 233| | // Caller guarantees buffer has enough space 234| | const auto start = reinterpret_cast(&b[ix]); 235| | auto result = std::format_to(start, fmt, V(value)); 236| | ix += size_t(result - start); 237| | } 238| | else { 239| | // format_to_n writes up to 'available' chars and returns total size needed. 240| | // Common case: output fits in pre-allocated buffer (single pass). 241| | // Rare case: output exceeds buffer (e.g., "{:.100f}"), requires resize. 242| | const auto start = reinterpret_cast(&b[ix]); 243| | const auto available = b.size() - ix; 244| | auto [out, size] = std::format_to_n(start, available, fmt, V(value)); 245| | 246| | if (static_cast(size) > available) { 247| | // Output was truncated - size tells us exactly how much space we need 248| | if constexpr (resizable) { 249| | grow_buffer(b, ix + size); 250| | std::format_to(reinterpret_cast(&b[ix]), fmt, V(value)); 251| | } 252| | else { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | ix += size; 258| | } 259| |#else 260| | // snprintf fallback for platforms without std::format float support (e.g., iOS < 16.3) 261| | // Convert std::format spec to printf format at compile time 262| | constexpr auto printf_fmt = detail::to_printf_fmt(opts_type::float_format); 263| | 264| | const auto start = reinterpret_cast(&b[ix]); 265| | const auto available = check_write_unchecked(Opts) ? size_t(64) : (b.size() - ix); 266| | 267| | // snprintf returns chars that would be written (excluding null), or negative on error 268| | const int len = std::snprintf(start, available, printf_fmt.data, static_cast(value)); 269| | 270| | if (len < 0) { 271| | ctx.error = error_code::unexpected_end; 272| | return; 273| | } 274| | 275| | if (static_cast(len) >= available) { 276| | // Output was truncated, need to resize and retry 277| | if constexpr (resizable && not check_write_unchecked(Opts)) { 278| | grow_buffer(b, ix + static_cast(len) + 1); 279| | std::snprintf(reinterpret_cast(&b[ix]), static_cast(len) + 1, printf_fmt.data, 280| | static_cast(value)); 281| | } 282| | else { 283| | ctx.error = error_code::unexpected_end; 284| | return; 285| | } 286| | } 287| | ix += static_cast(len); 288| |#endif 289| | } 290| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) > 0 && 291| | uint8_t(check_float_max_write_precision(Opts)) < sizeof(V)) { 292| | // we cast to a lower precision floating point value before writing out 293| | if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 8) { 294| | const auto reduced = static_cast(value); 295| | const auto start = reinterpret_cast(&b[ix]); 296| | const auto end = glz::to_chars(start, reduced); 297| | ix += size_t(end - start); 298| | } 299| | else if constexpr (uint8_t(check_float_max_write_precision(Opts)) == 4) { 300| | const auto reduced = static_cast(value); 301| | const auto start = reinterpret_cast(&b[ix]); 302| | const auto end = glz::to_chars(start, reduced); 303| | ix += size_t(end - start); 304| | } 305| | else { 306| | static_assert(false_v, "invalid float_max_write_precision"); 307| | } 308| | } 309| | // Size optimization: pass OptSize=true so the ~17KB pow-10 lookup 310| | // tables are dropped (recomputed on the fly). Much faster than the 311| | // old simple_float::to_chars path at essentially the same footprint. 312| | // See discussion #2519. 313| | else if constexpr (is_size_optimized(Opts) && is_any_of) { 314| | const auto start = reinterpret_cast(&b[ix]); 315| | const auto end = glz::to_chars(start, V(value)); 316| | ix += size_t(end - start); 317| | } 318| 2.82k| else if constexpr (is_any_of) { 319| 2.82k| const auto start = reinterpret_cast(&b[ix]); 320| 2.82k| const auto end = glz::to_chars(start, value); 321| 2.82k| ix += size_t(end - start); 322| | } 323| |// float128_t requires std::to_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 324| |#if !defined(_LIBCPP_VERSION) || _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT 325| | else if constexpr (is_float128) { 326| | const auto start = reinterpret_cast(&b[ix]); 327| | const auto [ptr, ec] = std::to_chars(start, &b[0] + b.size(), value, std::chars_format::general); 328| | if (ec != std::errc()) { 329| | ctx.error = error_code::unexpected_end; 330| | return; 331| | } 332| | ix += size_t(ptr - start); 333| | } 334| |#endif 335| | else { 336| | static_assert(false_v, "type is not supported"); 337| | } 338| | } 339| | else if constexpr (is_any_of) { 340| | // Small integers: always use to_chars (400B tables) 341| | // The 40KB digit_quads table doesn't help for these small ranges 342| | const auto start = reinterpret_cast(&b[ix]); 343| | const auto end = glz::to_chars(start, value); 344| | ix += size_t(end - start); 345| | } 346| | else if constexpr (is_any_of) { 347| | const auto start = reinterpret_cast(&b[ix]); 348| | if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| | const auto end = glz::to_chars(start, value); 351| | ix += size_t(end - start); 352| | } 353| | else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| | const auto end = glz::to_chars_40kb(start, value); 356| | ix += size_t(end - start); 357| | } 358| | } 359| | else if constexpr (std::integral) { 360| | // Handle other integral types (char, wchar_t, etc.) by casting to sized types 361| | using X = std::decay_t())>; 362| | const auto start = reinterpret_cast(&b[ix]); 363| | if constexpr (is_size_optimized(Opts)) { 364| | // Size mode: use glz::to_chars (400B lookup tables) 365| | const auto end = glz::to_chars(start, static_cast(value)); 366| | ix += size_t(end - start); 367| | } 368| | else { 369| | // Normal mode: use to_chars_40kb 370| | const auto end = glz::to_chars_40kb(start, static_cast(value)); 371| | ix += size_t(end - start); 372| | } 373| | } 374| | else { 375| | static_assert(false_v, "type is not supported"); 376| | } 377| 2.82k| } _ZN3glz9sweethash7sweet32ITkNS0_16contiguous_rangeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEjRKT_j: 270| 600| { 271| 600| return sweet32(static_cast(s.data()), s.size(), seed); 272| 600| } _ZN3glz9sweethash7sweet32EPKvmj: 154| 600| { 155| 600| const uint8_t* p = static_cast(data); 156| | 157| | // For inputs <= 8 bytes, use simple hash (tail handler requires len >= 9) 158| 600| if (len <= 8) { ------------------ | Branch (158:11): [True: 600, False: 0] ------------------ 159| 600| uint64_t v = 0; 160| 600| switch (len) { 161| 100| case 8: ------------------ | Branch (161:10): [True: 100, False: 500] ------------------ 162| 100| std::memcpy(&v, p, 8); 163| 100| break; 164| 100| case 7: ------------------ | Branch (164:10): [True: 100, False: 500] ------------------ 165| 100| std::memcpy(&v, p, 7); 166| 100| break; 167| 50| case 6: ------------------ | Branch (167:10): [True: 50, False: 550] ------------------ 168| 50| std::memcpy(&v, p, 6); 169| 50| break; 170| 300| case 5: ------------------ | Branch (170:10): [True: 300, False: 300] ------------------ 171| 300| std::memcpy(&v, p, 5); 172| 300| break; 173| 50| case 4: ------------------ | Branch (173:10): [True: 50, False: 550] ------------------ 174| 50| std::memcpy(&v, p, 4); 175| 50| break; 176| 0| case 3: ------------------ | Branch (176:10): [True: 0, False: 600] ------------------ 177| 0| std::memcpy(&v, p, 3); 178| 0| break; 179| 0| case 2: ------------------ | Branch (179:10): [True: 0, False: 600] ------------------ 180| 0| std::memcpy(&v, p, 2); 181| 0| break; 182| 0| case 1: ------------------ | Branch (182:10): [True: 0, False: 600] ------------------ 183| 0| v = p[0]; 184| 0| break; 185| 0| default: ------------------ | Branch (185:10): [True: 0, False: 600] ------------------ 186| 0| break; 187| 600| } 188| 600| v = v ^ seed ^ (len + 1); 189| 600| return static_cast(v) ^ static_cast(v >> 32); 190| 600| } 191| | 192| | // Full hash for inputs > 8 bytes 193| 0| uint64_t seed64 = (static_cast(seed) << 32) | static_cast(seed); 194| 0| uint64_t h = (seed64 ^ prime4) + (len * prime1); 195| 0| const uint8_t* const end = p + len; 196| | 197| 0| if (len >= 32) { ------------------ | Branch (197:11): [True: 0, False: 0] ------------------ 198| 0| uint64_t h1 = h; 199| 0| uint64_t h2 = (seed64 * prime2) ^ prime3; 200| 0| uint64_t h3 = (seed64 * prime3) ^ prime4; 201| 0| uint64_t h4 = (seed64 * prime4) ^ prime5; 202| | 203| 0| do { 204| 0| uint64_t k1, k2, k3, k4; 205| 0| std::memcpy(&k1, p, 8); 206| 0| std::memcpy(&k2, p + 8, 8); 207| 0| std::memcpy(&k3, p + 16, 8); 208| 0| std::memcpy(&k4, p + 24, 8); 209| | 210| 0| k1 = k1 * prime2; 211| 0| k1 = k1 ^ (k1 >> 47); 212| 0| h1 = h1 ^ k1; 213| 0| h1 = h1 * prime1; 214| | 215| 0| k2 = k2 * prime3; 216| 0| k2 = k2 ^ (k2 >> 47); 217| 0| h2 = h2 ^ k2; 218| 0| h2 = h2 * prime2; 219| | 220| 0| k3 = k3 * prime4; 221| 0| k3 = k3 ^ (k3 >> 47); 222| 0| h3 = h3 ^ k3; 223| 0| h3 = h3 * prime3; 224| | 225| 0| k4 = k4 * prime5; 226| 0| k4 = k4 ^ (k4 >> 47); 227| 0| h4 = h4 ^ k4; 228| 0| h4 = h4 * prime4; 229| | 230| 0| p = p + 32; 231| 0| len = len - 32; 232| 0| } while (len >= 32); ------------------ | Branch (232:19): [True: 0, False: 0] ------------------ 233| | 234| 0| h = h1 + h2 + h3 + h4; 235| 0| } 236| | 237| 0| while (len >= 8) { ------------------ | Branch (237:14): [True: 0, False: 0] ------------------ 238| 0| uint64_t k; 239| 0| std::memcpy(&k, p, 8); 240| 0| k = k * prime2; 241| 0| k = k ^ (k >> 47); 242| 0| h = h ^ k; 243| 0| h = h * prime1; 244| 0| p = p + 8; 245| 0| len = len - 8; 246| 0| } 247| | 248| 0| if (len > 0) { ------------------ | Branch (248:11): [True: 0, False: 0] ------------------ 249| 0| uint64_t k; 250| 0| std::memcpy(&k, end - 8, 8); 251| 0| k = k * prime2; 252| 0| k = k ^ (k >> 47); 253| 0| k = k * prime3; 254| 0| h = h ^ k; 255| 0| } 256| | 257| 0| h = mix64(h); 258| 0| return static_cast(h) ^ static_cast(h >> 32); 259| 600| } _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2Ev: 338| 1.75M| generic_json() = default; _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2EOS3_: 341| 1.79M| generic_json(generic_json&& other) noexcept : data(std::move(other.data)) {} _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEED2Ev: 114| 3.55M| ~generic_json() = default; _ZN3glz11get_as_jsonINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEETnNS_14string_literalEXtlNS8_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERS6_EENS1_8expectedIT_NS_9error_ctxEEEOT2_: 209| 112k| { 210| 112k| const auto str = glz::get_view_json(buffer); 211| 112k| if (str) { ------------------ | Branch (211:11): [True: 14.1k, False: 97.8k] ------------------ 212| 14.1k| T value{}; 213| 14.1k| context ctx{}; 214| 14.1k| if (const auto ec = glz::read(value, *str, ctx); ec) { ------------------ | Branch (214:65): [True: 10.9k, False: 3.19k] ------------------ 215| 10.9k| return unexpected(ec); 216| 10.9k| } 217| 3.19k| return value; 218| 14.1k| } 219| 97.8k| return unexpected(str.error()); 220| 112k| } _ZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_: 24| 112k| { 25| 112k| static constexpr auto S = chars; 26| 112k| static constexpr auto tokens = split_json_ptr(); 27| 112k| static constexpr auto N = tokens.size(); 28| | 29| 112k| context ctx{}; 30| 112k| auto p = read_iterators(buffer); 31| | 32| 112k| auto it = p.first; 33| 112k| auto end = p.second; 34| | 35| | // Don't automatically const qualify the buffer so we can write to the view, 36| | // which allows us to write to a JSON Pointer location 37| 112k| using span_t = 38| 112k| std::span>, const char, char>>; 39| 112k| using result_t = expected; 40| | 41| 112k| auto start = it; 42| | 43| 112k| if (buffer.empty()) [[unlikely]] { ------------------ | Branch (43:11): [True: 0, False: 112k] ------------------ 44| 0| ctx.error = error_code::no_read_input; 45| 0| } 46| | 47| 112k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (47:11): [True: 0, False: 112k] ------------------ 48| 0| return result_t{unexpected(error_ctx{0, ctx.error})}; 49| 0| } 50| | 51| | if constexpr (N == 0) { 52| | return result_t{span_t{it, end}}; 53| | } 54| 112k| else { 55| 112k| using namespace glz::detail; 56| | 57| 112k| skip_ws(ctx, it, end); 58| | 59| 112k| result_t ret; 60| | 61| 112k| for_each([&]() { 62| 112k| if (bool(ctx.error)) [[unlikely]] { 63| 112k| return; 64| 112k| } 65| | 66| 112k| static constexpr auto key = tokens[I]; 67| 112k| if constexpr (maybe_numeric_key(key)) { 68| 112k| switch (*it) { 69| 112k| case '{': { 70| 112k| ++it; 71| 112k| while (true) { 72| 112k| if (skip_ws(ctx, it, end)) { 73| 112k| return; 74| 112k| } 75| 112k| if (match<'"'>(ctx, it)) { 76| 112k| return; 77| 112k| } 78| | 79| 112k| auto* start = it; 80| 112k| skip_string_view(ctx, it, end); 81| 112k| if (bool(ctx.error)) [[unlikely]] 82| 112k| return; 83| 112k| const sv k = {start, size_t(it - start)}; 84| 112k| ++it; 85| | 86| 112k| if (key.size() == k.size() && comparitor(k.data())) { 87| 112k| if (skip_ws(ctx, it, end)) { 88| 112k| return; 89| 112k| } 90| 112k| if (match_invalid_end<':', Opts>(ctx, it, end)) { 91| 112k| return; 92| 112k| } 93| 112k| if (skip_ws(ctx, it, end)) { 94| 112k| return; 95| 112k| } 96| | 97| 112k| if constexpr (I == (N - 1)) { 98| 112k| ret = parse_value(ctx, it, end); 99| 112k| } 100| 112k| return; 101| 112k| } 102| 112k| else { 103| 112k| skip_value::op(ctx, it, end); 104| 112k| if (bool(ctx.error)) [[unlikely]] { 105| 112k| return; 106| 112k| } 107| 112k| if (it >= end || *it != ',') { 108| 112k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 109| 112k| return; 110| 112k| } 111| 112k| ++it; 112| 112k| } 113| 112k| } 114| 112k| } 115| 112k| case '[': { 116| 112k| ++it; 117| | // Could optimize by counting commas 118| 112k| static constexpr auto n = stoui(key); 119| 112k| if constexpr (n) { 120| 112k| for_each([&]() { 121| 112k| skip_value::op(ctx, it, end); 122| 112k| if (bool(ctx.error)) [[unlikely]] { 123| 112k| return; 124| 112k| } 125| 112k| if (it >= end || *it != ',') { 126| 112k| ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found; 127| 112k| return; 128| 112k| } 129| 112k| ++it; 130| 112k| }); 131| | 132| 112k| if (skip_ws(ctx, it, end)) { 133| 112k| return; 134| 112k| } 135| | 136| 112k| if constexpr (I == (N - 1)) { 137| 112k| ret = parse_value(ctx, it, end); 138| 112k| } 139| 112k| return; 140| 112k| } 141| 112k| else { 142| 112k| ctx.error = error_code::array_element_not_found; 143| 112k| return; 144| 112k| } 145| 112k| } 146| 112k| } 147| 112k| } 148| 112k| else { 149| 112k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { 150| 112k| return; 151| 112k| } 152| | 153| 112k| while (it < end) { 154| 112k| if (skip_ws(ctx, it, end)) { 155| 112k| return; 156| 112k| } 157| 112k| if (match<'"'>(ctx, it)) { 158| 112k| return; 159| 112k| } 160| | 161| 112k| auto* start = it; 162| 112k| skip_string_view(ctx, it, end); 163| 112k| if (bool(ctx.error)) [[unlikely]] 164| 112k| return; 165| 112k| const sv k = {start, size_t(it - start)}; 166| 112k| ++it; 167| | 168| 112k| if (key.size() == k.size() && comparitor(k.data())) { 169| 112k| if (skip_ws(ctx, it, end)) { 170| 112k| return; 171| 112k| } 172| 112k| if (match_invalid_end<':', Opts>(ctx, it, end)) { 173| 112k| return; 174| 112k| } 175| 112k| if (skip_ws(ctx, it, end)) { 176| 112k| return; 177| 112k| } 178| | 179| 112k| if constexpr (I == (N - 1)) { 180| 112k| ret = parse_value(ctx, it, end); 181| 112k| } 182| 112k| return; 183| 112k| } 184| 112k| else { 185| 112k| skip_value::op(ctx, it, end); 186| 112k| if (bool(ctx.error)) [[unlikely]] { 187| 112k| return; 188| 112k| } 189| 112k| if (it >= end || *it != ',') { 190| 112k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 191| 112k| return; 192| 112k| } 193| 112k| ++it; 194| 112k| } 195| 112k| } 196| 112k| } 197| 112k| }); 198| | 199| 112k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (199:14): [True: 97.8k, False: 14.1k] ------------------ 200| 97.8k| return result_t{unexpected(error_ctx{size_t(it - start), ctx.error})}; 201| 97.8k| } 202| | 203| 14.1k| return ret; 204| 112k| } 205| 112k| } _ZZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDav: 61| 112k| for_each([&]() { 62| 112k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (62:17): [True: 0, False: 112k] ------------------ 63| 0| return; 64| 0| } 65| | 66| 112k| static constexpr auto key = tokens[I]; 67| | if constexpr (maybe_numeric_key(key)) { 68| | switch (*it) { 69| | case '{': { 70| | ++it; 71| | while (true) { 72| | if (skip_ws(ctx, it, end)) { 73| | return; 74| | } 75| | if (match<'"'>(ctx, it)) { 76| | return; 77| | } 78| | 79| | auto* start = it; 80| | skip_string_view(ctx, it, end); 81| | if (bool(ctx.error)) [[unlikely]] 82| | return; 83| | const sv k = {start, size_t(it - start)}; 84| | ++it; 85| | 86| | if (key.size() == k.size() && comparitor(k.data())) { 87| | if (skip_ws(ctx, it, end)) { 88| | return; 89| | } 90| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 91| | return; 92| | } 93| | if (skip_ws(ctx, it, end)) { 94| | return; 95| | } 96| | 97| | if constexpr (I == (N - 1)) { 98| | ret = parse_value(ctx, it, end); 99| | } 100| | return; 101| | } 102| | else { 103| | skip_value::op(ctx, it, end); 104| | if (bool(ctx.error)) [[unlikely]] { 105| | return; 106| | } 107| | if (it >= end || *it != ',') { 108| | ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 109| | return; 110| | } 111| | ++it; 112| | } 113| | } 114| | } 115| | case '[': { 116| | ++it; 117| | // Could optimize by counting commas 118| | static constexpr auto n = stoui(key); 119| | if constexpr (n) { 120| | for_each([&]() { 121| | skip_value::op(ctx, it, end); 122| | if (bool(ctx.error)) [[unlikely]] { 123| | return; 124| | } 125| | if (it >= end || *it != ',') { 126| | ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found; 127| | return; 128| | } 129| | ++it; 130| | }); 131| | 132| | if (skip_ws(ctx, it, end)) { 133| | return; 134| | } 135| | 136| | if constexpr (I == (N - 1)) { 137| | ret = parse_value(ctx, it, end); 138| | } 139| | return; 140| | } 141| | else { 142| | ctx.error = error_code::array_element_not_found; 143| | return; 144| | } 145| | } 146| | } 147| | } 148| 112k| else { 149| 112k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (149:20): [True: 91.6k, False: 20.4k] ------------------ 150| 91.6k| return; 151| 91.6k| } 152| | 153| 30.9k| while (it < end) { ------------------ | Branch (153:23): [True: 30.9k, False: 0] ------------------ 154| 30.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (154:23): [True: 0, False: 30.9k] ------------------ 155| 0| return; 156| 0| } 157| 30.9k| if (match<'"'>(ctx, it)) { ------------------ | Branch (157:23): [True: 0, False: 30.9k] ------------------ 158| 0| return; 159| 0| } 160| | 161| 30.9k| auto* start = it; 162| 30.9k| skip_string_view(ctx, it, end); 163| 30.9k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (163:23): [True: 0, False: 30.9k] ------------------ 164| 0| return; 165| 30.9k| const sv k = {start, size_t(it - start)}; 166| 30.9k| ++it; 167| | 168| 30.9k| if (key.size() == k.size() && comparitor(k.data())) { ------------------ | Branch (168:23): [True: 16.3k, False: 14.6k] | Branch (168:49): [True: 14.1k, False: 2.19k] ------------------ 169| 14.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (169:26): [True: 0, False: 14.1k] ------------------ 170| 0| return; 171| 0| } 172| 14.1k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (172:26): [True: 0, False: 14.1k] ------------------ 173| 0| return; 174| 0| } 175| 14.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (175:26): [True: 0, False: 14.1k] ------------------ 176| 0| return; 177| 0| } 178| | 179| 14.1k| if constexpr (I == (N - 1)) { 180| 14.1k| ret = parse_value(ctx, it, end); 181| 14.1k| } 182| 14.1k| return; 183| 14.1k| } 184| 16.8k| else { 185| 16.8k| skip_value::op(ctx, it, end); 186| 16.8k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (186:26): [True: 0, False: 16.8k] ------------------ 187| 0| return; 188| 0| } 189| 16.8k| if (it >= end || *it != ',') { ------------------ | Branch (189:26): [True: 0, False: 16.8k] | Branch (189:39): [True: 6.24k, False: 10.5k] ------------------ 190| 6.24k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; ------------------ | Branch (190:37): [True: 0, False: 6.24k] ------------------ 191| 6.24k| return; 192| 6.24k| } 193| 10.5k| ++it; 194| 10.5k| } 195| 30.9k| } 196| 20.4k| } 197| 112k| }); _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 767| 856k| { 768| | if constexpr (check_quoted_num(Opts)) { 769| | if (skip_ws(ctx, it, end)) { 770| | return; 771| | } 772| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 773| | return; 774| | } 775| | } 776| | 777| | if constexpr (!check_ws_handled(Opts)) { 778| | if (skip_ws(ctx, it, end)) { 779| | return; 780| | } 781| | } 782| | 783| 856k| using V = std::decay_t; 784| 856k| if constexpr (int_t) { 785| 856k| static_assert(sizeof(*it) == sizeof(char)); 786| | 787| | if constexpr (Opts.null_terminated) { 788| | if (not glz::atoi(value, it)) [[unlikely]] { 789| | ctx.error = error_code::parse_number_failure; 790| | return; 791| | } 792| | } 793| 856k| else { 794| 856k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (794:20): [True: 4.02k, False: 852k] ------------------ 795| 4.02k| ctx.error = error_code::parse_number_failure; 796| 4.02k| return; 797| 4.02k| } 798| 856k| } 799| | } 800| | else { 801| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 802| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 803| | if constexpr (is_float128) { 804| | auto [ptr, ec] = std::from_chars(it, end, value); 805| | if (ec != std::errc()) { 806| | ctx.error = error_code::parse_number_failure; 807| | return; 808| | } 809| | it = ptr; 810| | } 811| | else 812| |#endif 813| | { 814| | if constexpr (std::is_volatile_v>) { 815| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 816| | // place 817| | V temp; 818| | if constexpr (is_size_optimized(Opts)) { 819| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 820| | if (ec != std::errc{}) [[unlikely]] { 821| | ctx.error = error_code::parse_number_failure; 822| | return; 823| | } 824| | it = ptr; 825| | } 826| | else { 827| | auto [ptr, ec] = glz::from_chars(it, end, temp); 828| | if (ec != std::errc()) [[unlikely]] { 829| | ctx.error = error_code::parse_number_failure; 830| | return; 831| | } 832| | it = ptr; 833| | } 834| | value = temp; 835| | } 836| | else { 837| | if constexpr (is_size_optimized(Opts)) { 838| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 839| | if (ec != std::errc{}) [[unlikely]] { 840| | ctx.error = error_code::parse_number_failure; 841| | return; 842| | } 843| | it = ptr; 844| | } 845| | else { 846| | auto [ptr, ec] = glz::from_chars(it, end, value); 847| | if (ec != std::errc()) [[unlikely]] { 848| | ctx.error = error_code::parse_number_failure; 849| | return; 850| | } 851| | it = ptr; 852| | } 853| | } 854| | } 855| | } 856| | 857| | if constexpr (check_quoted_num(Opts)) { 858| | if constexpr (not Opts.null_terminated) { 859| | if (it == end) [[unlikely]] { 860| | ctx.error = error_code::unexpected_end; 861| | return; 862| | } 863| | } 864| | if (match<'"'>(ctx, it)) { 865| | return; 866| | } 867| | if constexpr (not Opts.null_terminated) { 868| | if (it == end) { 869| | ctx.error = error_code::end_reached; 870| | return; 871| | } 872| | } 873| | } 874| 856k| else { 875| 856k| if constexpr (not Opts.null_terminated) { 876| 856k| if (it == end) { ------------------ | Branch (876:20): [True: 0, False: 856k] ------------------ 877| 0| ctx.error = error_code::end_reached; 878| 0| return; 879| 0| } 880| 856k| } 881| 856k| } 882| 856k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 1.28k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.28k| else { 60| 1.28k| using V = std::remove_cvref_t; 61| 1.28k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.28k| end); 63| 1.28k| } 64| 1.28k| } _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 767| 1.28k| { 768| | if constexpr (check_quoted_num(Opts)) { 769| | if (skip_ws(ctx, it, end)) { 770| | return; 771| | } 772| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 773| | return; 774| | } 775| | } 776| | 777| 1.28k| if constexpr (!check_ws_handled(Opts)) { 778| 1.28k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (778:17): [True: 0, False: 1.28k] ------------------ 779| 0| return; 780| 0| } 781| 1.28k| } 782| | 783| 1.28k| using V = std::decay_t; 784| 1.28k| if constexpr (int_t) { 785| 1.28k| static_assert(sizeof(*it) == sizeof(char)); 786| | 787| | if constexpr (Opts.null_terminated) { 788| | if (not glz::atoi(value, it)) [[unlikely]] { 789| | ctx.error = error_code::parse_number_failure; 790| | return; 791| | } 792| | } 793| 1.28k| else { 794| 1.28k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (794:20): [True: 640, False: 646] ------------------ 795| 640| ctx.error = error_code::parse_number_failure; 796| 640| return; 797| 640| } 798| 1.28k| } 799| | } 800| | else { 801| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 802| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 803| | if constexpr (is_float128) { 804| | auto [ptr, ec] = std::from_chars(it, end, value); 805| | if (ec != std::errc()) { 806| | ctx.error = error_code::parse_number_failure; 807| | return; 808| | } 809| | it = ptr; 810| | } 811| | else 812| |#endif 813| | { 814| | if constexpr (std::is_volatile_v>) { 815| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 816| | // place 817| | V temp; 818| | if constexpr (is_size_optimized(Opts)) { 819| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 820| | if (ec != std::errc{}) [[unlikely]] { 821| | ctx.error = error_code::parse_number_failure; 822| | return; 823| | } 824| | it = ptr; 825| | } 826| | else { 827| | auto [ptr, ec] = glz::from_chars(it, end, temp); 828| | if (ec != std::errc()) [[unlikely]] { 829| | ctx.error = error_code::parse_number_failure; 830| | return; 831| | } 832| | it = ptr; 833| | } 834| | value = temp; 835| | } 836| | else { 837| | if constexpr (is_size_optimized(Opts)) { 838| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 839| | if (ec != std::errc{}) [[unlikely]] { 840| | ctx.error = error_code::parse_number_failure; 841| | return; 842| | } 843| | it = ptr; 844| | } 845| | else { 846| | auto [ptr, ec] = glz::from_chars(it, end, value); 847| | if (ec != std::errc()) [[unlikely]] { 848| | ctx.error = error_code::parse_number_failure; 849| | return; 850| | } 851| | it = ptr; 852| | } 853| | } 854| | } 855| | } 856| | 857| | if constexpr (check_quoted_num(Opts)) { 858| | if constexpr (not Opts.null_terminated) { 859| | if (it == end) [[unlikely]] { 860| | ctx.error = error_code::unexpected_end; 861| | return; 862| | } 863| | } 864| | if (match<'"'>(ctx, it)) { 865| | return; 866| | } 867| | if constexpr (not Opts.null_terminated) { 868| | if (it == end) { 869| | ctx.error = error_code::end_reached; 870| | return; 871| | } 872| | } 873| | } 874| 1.28k| else { 875| 1.28k| if constexpr (not Opts.null_terminated) { 876| 1.28k| if (it == end) { ------------------ | Branch (876:20): [True: 503, False: 783] ------------------ 877| 503| ctx.error = error_code::end_reached; 878| 503| return; 879| 503| } 880| 1.28k| } 881| 1.28k| } 882| 1.28k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 1.17k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.17k| else { 60| 1.17k| using V = std::remove_cvref_t; 61| 1.17k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.17k| end); 63| 1.17k| } 64| 1.17k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 1.17k| { 3045| 1.17k| static constexpr auto num_members = reflect::size; 3046| | 3047| 1.17k| static constexpr auto Opts = opening_handled_off()>(); 3048| 1.17k| if constexpr (!check_opening_handled(Options)) { 3049| 1.17k| if constexpr (!check_ws_handled(Options)) { 3050| 1.17k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3050:20): [True: 0, False: 1.17k] ------------------ 3051| 0| return; 3052| 0| } 3053| 1.17k| } 3054| 1.17k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 277, False: 902] ------------------ 3055| 277| return; 3056| 277| } 3057| 902| if constexpr (not Opts.null_terminated) { 3058| 902| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 902] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 902| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 902| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 902] ------------------ 3066| 0| return; 3067| 0| } 3068| 902| } 3069| 902| const auto ws_start = it; 3070| 1.17k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 1.17k] ------------------ 3071| 0| return; 3072| 0| } 3073| 1.17k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 1.17k| else { 3148| 1.17k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 1.17k| if constexpr ((glaze_object_t || reflectable) && 3150| 1.17k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 1.17k| return bit_array{}; 3152| 1.17k| } 3153| 1.17k| else { 3154| 1.17k| return nullptr; 3155| 1.17k| } 3156| 1.17k| }(); 3157| | 3158| 1.17k| size_t read_count{}; // for partial_read 3159| | 3160| 1.17k| bool first = true; 3161| 5.32k| while (true) { ------------------ | Branch (3161:20): [True: 4.30k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 4.30k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 122, False: 4.18k] ------------------ 3199| 122| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 122| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 122| } 3224| 122| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 122| if constexpr (not Opts.null_terminated) { 3226| 122| if (it == end) { ------------------ | Branch (3226:26): [True: 122, False: 0] ------------------ 3227| 122| ctx.error = error_code::end_reached; 3228| 122| return; 3229| 122| } 3230| 122| } 3231| 0| return; 3232| 122| } 3233| 4.18k| else if (first) { ------------------ | Branch (3233:25): [True: 865, False: 3.31k] ------------------ 3234| 865| first = false; 3235| 865| } 3236| 3.31k| else { 3237| 3.31k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 36, False: 3.28k] ------------------ 3238| 36| return; 3239| 36| } 3240| 3.28k| if constexpr (not Opts.null_terminated) { 3241| 3.28k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 3.28k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 3.28k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 3.28k| (!Opts.comments)) { 3249| 3.28k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 3.03k, False: 243] | Branch (3249:37): [True: 2.83k, False: 206] ------------------ 3250| 2.83k| skip_matching_ws(ws_start, it, ws_size); 3251| 2.83k| } 3252| 3.28k| } 3253| | 3254| 3.28k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 3.28k] ------------------ 3255| 0| return; 3256| 0| } 3257| 3.28k| } 3258| | 3259| 4.14k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 4.14k| else if constexpr (reflection_type) { 3324| 4.14k| static_assert(bool(hash_info.type)); 3325| | 3326| 4.14k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 525, False: 3.62k] ------------------ 3327| 525| ctx.error = error_code::expected_quote; 3328| 525| return; 3329| 525| } 3330| 3.62k| ++it; 3331| 3.62k| if constexpr (not Opts.null_terminated) { 3332| 3.62k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 3.62k] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 3.62k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 3.62k| else { 3386| 3.62k| parse_and_invoke(value, ctx, it, end); 3387| 3.62k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 219, False: 3.40k] ------------------ 3388| 219| return; 3389| 3.62k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 4.14k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 4.14k] ------------------ 3499| 0| return; 3500| 0| } 3501| 4.14k| } 3502| 1.17k| } 3503| 1.17k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 902| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 902| else { 3154| 902| return nullptr; 3155| 902| } 3156| 902| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 376| 7.53k| { 377| 7.53k| constexpr auto N = reflect::size; 378| | 379| | if constexpr (N == 1) { 380| | decode_index(value, ctx, it, end, selected_index...); 381| | } 382| | else if constexpr (check_linear_search(Opts)) { 383| | // Linear search path 384| | auto key_start = it; 385| | const auto index = decode_linear(ctx, it, end); 386| | if (bool(ctx.error)) [[unlikely]] 387| | return; 388| | 389| | if (index >= N) [[unlikely]] { 390| | if constexpr (Opts.error_on_unknown_keys) { 391| | ctx.error = error_code::unknown_key; 392| | return; 393| | } 394| | else { 395| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 396| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 397| | return; 398| | } 399| | const sv key{key_start, size_t(it - key_start - 1)}; 400| | if constexpr (not Opts.null_terminated) { 401| | if (it == end) [[unlikely]] { 402| | ctx.error = error_code::unexpected_end; 403| | return; 404| | } 405| | } 406| | if (parse_ws_colon(ctx, it, end)) { 407| | return; 408| | } 409| | parse::handle_unknown(key, value, ctx, it, end); 410| | return; 411| | } 412| | } 413| | 414| | if constexpr (not Opts.null_terminated) { 415| | if (it == end) [[unlikely]] { 416| | ctx.error = error_code::unexpected_end; 417| | return; 418| | } 419| | } 420| | if (skip_ws(ctx, it, end)) { 421| | return; 422| | } 423| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 424| | return; 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | 430| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 431| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 432| | // instantiations; the whitespace before the value has already been skipped either way. 433| | [&](std::index_sequence) { 434| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 435| | : false) || 436| | ...)); 437| | }(std::make_index_sequence{}); 438| | } 439| 7.53k| else { 440| | // Hash-based lookup 441| 7.53k| constexpr auto& HashInfo = hash_info; 442| 7.53k| constexpr auto type = HashInfo.type; 443| 7.53k| static_assert(bool(type), "invalid hash algorithm"); 444| | 445| 7.53k| const auto index = decode_hash::op(it, end); 446| | 447| 7.53k| if (index >= N) [[unlikely]] { ------------------ | Branch (447:14): [True: 0, False: 7.53k] ------------------ 448| 0| if constexpr (Opts.error_on_unknown_keys) { 449| 0| ctx.error = error_code::unknown_key; 450| 0| return; 451| | } 452| | else { 453| | auto start = it; 454| | skip_string_view(ctx, it, end); 455| | if (bool(ctx.error)) [[unlikely]] 456| | return; 457| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 458| | return; 459| | const sv key = {start, size_t(it - start)}; 460| | ++it; // skip the quote 461| | if constexpr (not Opts.null_terminated) { 462| | if (it == end) [[unlikely]] { 463| | ctx.error = error_code::unexpected_end; 464| | return; 465| | } 466| | } 467| | if (parse_ws_colon(ctx, it, end)) { 468| | return; 469| | } 470| | parse::handle_unknown(key, value, ctx, it, end); 471| | return; 472| | } 473| 0| } 474| | 475| 7.53k| if constexpr (N == 2) { 476| 7.53k| if (index == 0) { ------------------ | Branch (476:17): [True: 6.11k, False: 1.42k] ------------------ 477| 6.11k| decode_index(value, ctx, it, end, selected_index...); 478| 6.11k| } 479| 1.42k| else { 480| 1.42k| decode_index(value, ctx, it, end, selected_index...); 481| 1.42k| } 482| | } 483| | else { 484| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 485| | } 486| 7.53k| } 487| 7.53k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 6.11k| { 312| 6.11k| static constexpr auto Key = get(reflect::keys); 313| 6.11k| static constexpr auto KeyWithEndQuote = join_v>; 314| 6.11k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 6.11k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 6.11k, False: 0] | Branch (316:36): [True: 6.10k, False: 13] ------------------ 317| 6.10k| it += Length; 318| 6.10k| if constexpr (not Opts.null_terminated) { 319| 6.10k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 6.10k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 6.10k| } 324| | 325| 6.10k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 6.10k] ------------------ 326| 0| return; 327| 0| } 328| 6.10k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 51, False: 6.04k] ------------------ 329| 51| return; 330| 51| } 331| 6.04k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 6.04k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 6.04k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 6.04k| } 338| 13| else [[unlikely]] { 339| 13| decode_index_unknown_key(value, ctx, it, end); 340| 13| } 341| 6.11k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 6.04k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 6.04k| else { 273| 6.04k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 6.04k| else { 297| 6.04k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 6.04k| it, end); 299| 6.04k| } 300| 6.04k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 6.04k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 767| 889k| { 768| | if constexpr (check_quoted_num(Opts)) { 769| | if (skip_ws(ctx, it, end)) { 770| | return; 771| | } 772| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 773| | return; 774| | } 775| | } 776| | 777| | if constexpr (!check_ws_handled(Opts)) { 778| | if (skip_ws(ctx, it, end)) { 779| | return; 780| | } 781| | } 782| | 783| 889k| using V = std::decay_t; 784| | if constexpr (int_t) { 785| | static_assert(sizeof(*it) == sizeof(char)); 786| | 787| | if constexpr (Opts.null_terminated) { 788| | if (not glz::atoi(value, it)) [[unlikely]] { 789| | ctx.error = error_code::parse_number_failure; 790| | return; 791| | } 792| | } 793| | else { 794| | if (not glz::atoi(value, it, end)) [[unlikely]] { 795| | ctx.error = error_code::parse_number_failure; 796| | return; 797| | } 798| | } 799| | } 800| 889k| else { 801| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 802| 889k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 803| | if constexpr (is_float128) { 804| | auto [ptr, ec] = std::from_chars(it, end, value); 805| | if (ec != std::errc()) { 806| | ctx.error = error_code::parse_number_failure; 807| | return; 808| | } 809| | it = ptr; 810| | } 811| | else 812| |#endif 813| 889k| { 814| | if constexpr (std::is_volatile_v>) { 815| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 816| | // place 817| | V temp; 818| | if constexpr (is_size_optimized(Opts)) { 819| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 820| | if (ec != std::errc{}) [[unlikely]] { 821| | ctx.error = error_code::parse_number_failure; 822| | return; 823| | } 824| | it = ptr; 825| | } 826| | else { 827| | auto [ptr, ec] = glz::from_chars(it, end, temp); 828| | if (ec != std::errc()) [[unlikely]] { 829| | ctx.error = error_code::parse_number_failure; 830| | return; 831| | } 832| | it = ptr; 833| | } 834| | value = temp; 835| | } 836| 889k| else { 837| | if constexpr (is_size_optimized(Opts)) { 838| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 839| | if (ec != std::errc{}) [[unlikely]] { 840| | ctx.error = error_code::parse_number_failure; 841| | return; 842| | } 843| | it = ptr; 844| | } 845| 889k| else { 846| 889k| auto [ptr, ec] = glz::from_chars(it, end, value); 847| 889k| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (847:26): [True: 1.09k, False: 888k] ------------------ 848| 1.09k| ctx.error = error_code::parse_number_failure; 849| 1.09k| return; 850| 1.09k| } 851| 888k| it = ptr; 852| 888k| } 853| 889k| } 854| 889k| } 855| 889k| } 856| | 857| | if constexpr (check_quoted_num(Opts)) { 858| | if constexpr (not Opts.null_terminated) { 859| | if (it == end) [[unlikely]] { 860| | ctx.error = error_code::unexpected_end; 861| | return; 862| | } 863| | } 864| | if (match<'"'>(ctx, it)) { 865| | return; 866| | } 867| | if constexpr (not Opts.null_terminated) { 868| | if (it == end) { 869| | ctx.error = error_code::end_reached; 870| | return; 871| | } 872| | } 873| | } 874| 889k| else { 875| 889k| if constexpr (not Opts.null_terminated) { 876| 889k| if (it == end) { ------------------ | Branch (876:20): [True: 0, False: 889k] ------------------ 877| 0| ctx.error = error_code::end_reached; 878| 0| return; 879| 0| } 880| 889k| } 881| 889k| } 882| 889k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 96| { 178| 96| if constexpr (Opts.error_on_unknown_keys) { 179| 96| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 96| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 1.42k| { 312| 1.42k| static constexpr auto Key = get(reflect::keys); 313| 1.42k| static constexpr auto KeyWithEndQuote = join_v>; 314| 1.42k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 1.42k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 1.41k, False: 6] | Branch (316:36): [True: 1.34k, False: 77] ------------------ 317| 1.34k| it += Length; 318| 1.34k| if constexpr (not Opts.null_terminated) { 319| 1.34k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 1.34k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 1.34k| } 324| | 325| 1.34k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 1.34k] ------------------ 326| 0| return; 327| 0| } 328| 1.34k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 44, False: 1.29k] ------------------ 329| 44| return; 330| 44| } 331| 1.29k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 1.29k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 1.29k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 1.29k| } 338| 83| else [[unlikely]] { 339| 83| decode_index_unknown_key(value, ctx, it, end); 340| 83| } 341| 1.42k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 1.29k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 1.29k| else { 273| 1.29k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 1.29k| else { 297| 1.29k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 1.29k| it, end); 299| 1.29k| } 300| 1.29k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 1.29k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 7.78k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 7.78k| else { 60| 7.78k| using V = std::remove_cvref_t; 61| 7.78k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 7.78k| end); 63| 7.78k| } 64| 7.78k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 7.78k| { 3045| 7.78k| static constexpr auto num_members = reflect::size; 3046| | 3047| 7.78k| static constexpr auto Opts = opening_handled_off()>(); 3048| 7.78k| if constexpr (!check_opening_handled(Options)) { 3049| 7.78k| if constexpr (!check_ws_handled(Options)) { 3050| 7.78k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3050:20): [True: 0, False: 7.78k] ------------------ 3051| 0| return; 3052| 0| } 3053| 7.78k| } 3054| 7.78k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 72, False: 7.70k] ------------------ 3055| 72| return; 3056| 72| } 3057| 7.70k| if constexpr (not Opts.null_terminated) { 3058| 7.70k| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 7.70k] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 7.70k| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 7.70k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 7.70k] ------------------ 3066| 0| return; 3067| 0| } 3068| 7.70k| } 3069| 7.70k| const auto ws_start = it; 3070| 7.78k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 7.78k] ------------------ 3071| 0| return; 3072| 0| } 3073| 7.78k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 7.78k| else { 3148| 7.78k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 7.78k| if constexpr ((glaze_object_t || reflectable) && 3150| 7.78k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 7.78k| return bit_array{}; 3152| 7.78k| } 3153| 7.78k| else { 3154| 7.78k| return nullptr; 3155| 7.78k| } 3156| 7.78k| }(); 3157| | 3158| 7.78k| size_t read_count{}; // for partial_read 3159| | 3160| 7.78k| bool first = true; 3161| 36.4k| while (true) { ------------------ | Branch (3161:20): [True: 29.7k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 29.7k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 734, False: 28.9k] ------------------ 3199| 734| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 734| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 734| } 3224| 734| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 734| if constexpr (not Opts.null_terminated) { 3226| 734| if (it == end) { ------------------ | Branch (3226:26): [True: 734, False: 0] ------------------ 3227| 734| ctx.error = error_code::end_reached; 3228| 734| return; 3229| 734| } 3230| 734| } 3231| 0| return; 3232| 734| } 3233| 28.9k| else if (first) { ------------------ | Branch (3233:25): [True: 7.68k, False: 21.2k] ------------------ 3234| 7.68k| first = false; 3235| 7.68k| } 3236| 21.2k| else { 3237| 21.2k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 318, False: 20.9k] ------------------ 3238| 318| return; 3239| 318| } 3240| 20.9k| if constexpr (not Opts.null_terminated) { 3241| 20.9k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 20.9k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 20.9k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 20.9k| (!Opts.comments)) { 3249| 20.9k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 9.85k, False: 11.1k] | Branch (3249:37): [True: 9.56k, False: 290] ------------------ 3250| 9.56k| skip_matching_ws(ws_start, it, ws_size); 3251| 9.56k| } 3252| 20.9k| } 3253| | 3254| 20.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 20.9k] ------------------ 3255| 0| return; 3256| 0| } 3257| 20.9k| } 3258| | 3259| 28.6k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 28.6k| else if constexpr (reflection_type) { 3324| 28.6k| static_assert(bool(hash_info.type)); 3325| | 3326| 28.6k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 800, False: 27.8k] ------------------ 3327| 800| ctx.error = error_code::expected_quote; 3328| 800| return; 3329| 800| } 3330| 27.8k| ++it; 3331| 27.8k| if constexpr (not Opts.null_terminated) { 3332| 27.8k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 27.8k] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 27.8k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 27.8k| else { 3386| 27.8k| parse_and_invoke(value, ctx, it, end); 3387| 27.8k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 5.85k, False: 22.0k] ------------------ 3388| 5.85k| return; 3389| 27.8k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 28.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 28.6k] ------------------ 3499| 0| return; 3500| 0| } 3501| 28.6k| } 3502| 7.78k| } 3503| 7.78k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 7.70k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 7.70k| else { 3154| 7.70k| return nullptr; 3155| 7.70k| } 3156| 7.70k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 376| 27.8k| { 377| 27.8k| constexpr auto N = reflect::size; 378| | 379| | if constexpr (N == 1) { 380| | decode_index(value, ctx, it, end, selected_index...); 381| | } 382| | else if constexpr (check_linear_search(Opts)) { 383| | // Linear search path 384| | auto key_start = it; 385| | const auto index = decode_linear(ctx, it, end); 386| | if (bool(ctx.error)) [[unlikely]] 387| | return; 388| | 389| | if (index >= N) [[unlikely]] { 390| | if constexpr (Opts.error_on_unknown_keys) { 391| | ctx.error = error_code::unknown_key; 392| | return; 393| | } 394| | else { 395| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 396| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 397| | return; 398| | } 399| | const sv key{key_start, size_t(it - key_start - 1)}; 400| | if constexpr (not Opts.null_terminated) { 401| | if (it == end) [[unlikely]] { 402| | ctx.error = error_code::unexpected_end; 403| | return; 404| | } 405| | } 406| | if (parse_ws_colon(ctx, it, end)) { 407| | return; 408| | } 409| | parse::handle_unknown(key, value, ctx, it, end); 410| | return; 411| | } 412| | } 413| | 414| | if constexpr (not Opts.null_terminated) { 415| | if (it == end) [[unlikely]] { 416| | ctx.error = error_code::unexpected_end; 417| | return; 418| | } 419| | } 420| | if (skip_ws(ctx, it, end)) { 421| | return; 422| | } 423| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 424| | return; 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | 430| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 431| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 432| | // instantiations; the whitespace before the value has already been skipped either way. 433| | [&](std::index_sequence) { 434| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 435| | : false) || 436| | ...)); 437| | }(std::make_index_sequence{}); 438| | } 439| 27.8k| else { 440| | // Hash-based lookup 441| 27.8k| constexpr auto& HashInfo = hash_info; 442| 27.8k| constexpr auto type = HashInfo.type; 443| 27.8k| static_assert(bool(type), "invalid hash algorithm"); 444| | 445| 27.8k| const auto index = decode_hash::op(it, end); 446| | 447| 27.8k| if (index >= N) [[unlikely]] { ------------------ | Branch (447:14): [True: 68, False: 27.7k] ------------------ 448| 68| if constexpr (Opts.error_on_unknown_keys) { 449| 68| ctx.error = error_code::unknown_key; 450| 68| return; 451| | } 452| | else { 453| | auto start = it; 454| | skip_string_view(ctx, it, end); 455| | if (bool(ctx.error)) [[unlikely]] 456| | return; 457| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 458| | return; 459| | const sv key = {start, size_t(it - start)}; 460| | ++it; // skip the quote 461| | if constexpr (not Opts.null_terminated) { 462| | if (it == end) [[unlikely]] { 463| | ctx.error = error_code::unexpected_end; 464| | return; 465| | } 466| | } 467| | if (parse_ws_colon(ctx, it, end)) { 468| | return; 469| | } 470| | parse::handle_unknown(key, value, ctx, it, end); 471| | return; 472| | } 473| 68| } 474| | 475| | if constexpr (N == 2) { 476| | if (index == 0) { 477| | decode_index(value, ctx, it, end, selected_index...); 478| | } 479| | else { 480| | decode_index(value, ctx, it, end, selected_index...); 481| | } 482| | } 483| 27.8k| else { 484| 27.8k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 485| 27.8k| } 486| 27.8k| } 487| 27.8k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav: 484| 13.9k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 13.9k| { 312| 13.9k| static constexpr auto Key = get(reflect::keys); 313| 13.9k| static constexpr auto KeyWithEndQuote = join_v>; 314| 13.9k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 13.9k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 13.9k, False: 5] | Branch (316:36): [True: 13.9k, False: 29] ------------------ 317| 13.9k| it += Length; 318| 13.9k| if constexpr (not Opts.null_terminated) { 319| 13.9k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 13.9k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 13.9k| } 324| | 325| 13.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 13.9k] ------------------ 326| 0| return; 327| 0| } 328| 13.9k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 34, False: 13.9k] ------------------ 329| 34| return; 330| 34| } 331| 13.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 13.9k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 13.9k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 13.9k| } 338| 34| else [[unlikely]] { 339| 34| decode_index_unknown_key(value, ctx, it, end); 340| 34| } 341| 13.9k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 13.9k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 13.9k| else { 273| 13.9k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 13.9k| else { 297| 13.9k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 13.9k| it, end); 299| 13.9k| } 300| 13.9k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 13.9k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 388| { 178| 388| if constexpr (Opts.error_on_unknown_keys) { 179| 388| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 388| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav: 484| 286| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 286| { 312| 286| static constexpr auto Key = get(reflect::keys); 313| 286| static constexpr auto KeyWithEndQuote = join_v>; 314| 286| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 286| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 283, False: 3] | Branch (316:36): [True: 226, False: 57] ------------------ 317| 226| it += Length; 318| 226| if constexpr (not Opts.null_terminated) { 319| 226| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 226] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 226| } 324| | 325| 226| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 226] ------------------ 326| 0| return; 327| 0| } 328| 226| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 22, False: 204] ------------------ 329| 22| return; 330| 22| } 331| 204| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 204] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 204| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 204| } 338| 60| else [[unlikely]] { 339| 60| decode_index_unknown_key(value, ctx, it, end); 340| 60| } 341| 286| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 204| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 204| else { 273| 204| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 204| else { 297| 204| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 204| it, end); 299| 204| } 300| 204| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 204| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_: 1043| 752k| { 1044| | if constexpr (check_string_as_number(Opts)) { 1045| | auto start = it; 1046| | skip_number(ctx, it, end); 1047| | if (bool(ctx.error)) [[unlikely]] { 1048| | return; 1049| | } 1050| | if (start == it) [[unlikely]] { 1051| | ctx.error = error_code::parse_number_failure; 1052| | return; 1053| | } 1054| | value.append(start, size_t(it - start)); 1055| | } 1056| 752k| else { 1057| 752k| if constexpr (!check_opening_handled(Opts)) { 1058| | if constexpr (!check_ws_handled(Opts)) { 1059| | if (skip_ws(ctx, it, end)) { 1060| | return; 1061| | } 1062| | } 1063| | 1064| 752k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1064:20): [True: 98, False: 752k] ------------------ 1065| 98| return; 1066| 98| } 1067| 752k| } 1068| | 1069| 752k| if constexpr (not check_raw_string(Opts)) { 1070| 752k| static constexpr auto string_padding_bytes = 8; 1071| | 1072| 752k| if (size_t(end - it) >= 8) { ------------------ | Branch (1072:20): [True: 751k, False: 399] ------------------ 1073| 751k| auto start = it; 1074| 751k| uint64_t ascii_acc{}; 1075| 751k| const auto end8 = end - 8; 1076| 12.0M| while (true) { ------------------ | Branch (1076:26): [True: 12.0M, Folded] ------------------ 1077| 12.0M| if (it >= end8) [[unlikely]] { ------------------ | Branch (1077:26): [True: 876, False: 12.0M] ------------------ 1078| 876| break; 1079| 876| } 1080| | 1081| 12.0M| uint64_t chunk; 1082| 12.0M| std::memcpy(&chunk, it, 8); 1083| | if constexpr (std::endian::native == std::endian::big) { 1084| | chunk = std::byteswap(chunk); 1085| | } 1086| 12.0M| ascii_acc |= chunk; 1087| 12.0M| const uint64_t test_chars = has_quote(chunk); 1088| 12.0M| if (test_chars) { ------------------ | Branch (1088:26): [True: 995k, False: 11.0M] ------------------ 1089| 995k| it += (countr_zero(test_chars) >> 3); 1090| | 1091| 995k| auto* prev = it - 1; 1092| 1.33M| while (*prev == '\\') { ------------------ | Branch (1092:32): [True: 334k, False: 995k] ------------------ 1093| 334k| --prev; 1094| 334k| } 1095| 995k| if (size_t(it - prev) % 2) { ------------------ | Branch (1095:29): [True: 751k, False: 244k] ------------------ 1096| 751k| goto continue_decode; 1097| 751k| } 1098| 244k| ++it; // skip the escaped quote 1099| 244k| } 1100| 11.0M| else { 1101| 11.0M| it += 8; 1102| 11.0M| } 1103| 12.0M| } 1104| | 1105| 4.74k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (1105:26): [True: 3.87k, False: 876] ------------------ 1106| | // if we ended on an escape character then we need to rewind 1107| | // because we lost our context 1108| 3.87k| --it; 1109| 3.87k| } 1110| | 1111| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 1112| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 1113| 7.86k| for (; it < end; ++it) { ------------------ | Branch (1113:26): [True: 7.86k, False: 0] ------------------ 1114| 7.86k| ascii_acc |= uint8_t(*it); 1115| 7.86k| if (*it == '"') { ------------------ | Branch (1115:26): [True: 911, False: 6.94k] ------------------ 1116| 911| auto* prev = it - 1; 1117| 4.37k| while (*prev == '\\') { ------------------ | Branch (1117:32): [True: 3.46k, False: 911] ------------------ 1118| 3.46k| --prev; 1119| 3.46k| } 1120| 911| if (size_t(it - prev) % 2) { ------------------ | Branch (1120:29): [True: 876, False: 35] ------------------ 1121| 876| goto continue_decode; 1122| 876| } 1123| 911| } 1124| 7.86k| } 1125| | 1126| 0| ctx.error = error_code::unexpected_end; 1127| 0| return; 1128| | 1129| 751k| continue_decode: 1130| | 1131| 751k| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1131:23): [True: 14.3k, False: 737k] ------------------ 1132| 14.3k| return; 1133| 14.3k| } 1134| | 1135| 737k| const auto available_padding = size_t(end - it); 1136| 737k| auto n = size_t(it - start); 1137| 737k| if (available_padding >= 8) [[likely]] { ------------------ | Branch (1137:23): [True: 736k, False: 957] ------------------ 1138| 736k| value.resize(n + string_padding_bytes); 1139| | 1140| 736k| auto* p = value.data(); 1141| | 1142| 4.91M| while (true) { ------------------ | Branch (1142:29): [True: 4.91M, Folded] ------------------ 1143| 4.91M| if (start >= it) { ------------------ | Branch (1143:29): [True: 727k, False: 4.19M] ------------------ 1144| 727k| break; 1145| 727k| } 1146| | 1147| 4.19M| std::memcpy(p, start, 8); 1148| 4.19M| uint64_t swar; 1149| 4.19M| std::memcpy(&swar, p, 8); 1150| | if constexpr (std::endian::native == std::endian::big) { 1151| | swar = std::byteswap(swar); 1152| | } 1153| | 1154| 4.19M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1155| 4.19M| const uint64_t lo7 = swar & lo7_mask; 1156| 4.19M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1157| 4.19M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1158| 4.19M| uint64_t next = ~((backslash & less_32) | swar); 1159| | 1160| 4.19M| next &= repeat_byte8(0b10000000); 1161| 4.19M| if (next == 0) { ------------------ | Branch (1161:29): [True: 3.72M, False: 462k] ------------------ 1162| 3.72M| start += 8; 1163| 3.72M| p += 8; 1164| 3.72M| continue; 1165| 3.72M| } 1166| | 1167| 462k| next = countr_zero(next) >> 3; 1168| 462k| start += next; 1169| 462k| if (start >= it) { ------------------ | Branch (1169:29): [True: 400, False: 462k] ------------------ 1170| 400| break; 1171| 400| } 1172| | 1173| 462k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1173:29): [True: 8.56k, False: 453k] ------------------ 1174| 8.56k| ctx.error = error_code::syntax_error; 1175| 8.56k| return; 1176| 8.56k| } 1177| 453k| ++start; // skip the escape 1178| 453k| if (*start == 'u') { ------------------ | Branch (1178:29): [True: 1.77k, False: 451k] ------------------ 1179| 1.77k| ++start; 1180| 1.77k| p += next; 1181| 1.77k| const auto mark = start; 1182| 1.77k| const auto offset = handle_unicode_code_point(start, p, end); 1183| 1.77k| if (offset == 0) [[unlikely]] { ------------------ | Branch (1183:32): [True: 89, False: 1.68k] ------------------ 1184| 89| ctx.error = error_code::unicode_escape_conversion_failure; 1185| 89| return; 1186| 89| } 1187| 1.68k| n += offset; 1188| | // escape + u + unicode code points 1189| 1.68k| n -= 2 + uint32_t(start - mark); 1190| 1.68k| } 1191| 451k| else { 1192| 451k| p += next; 1193| 451k| *p = char_unescape_table[uint8_t(*start)]; 1194| 451k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1194:32): [True: 19, False: 451k] ------------------ 1195| 19| ctx.error = error_code::invalid_escape; 1196| 19| return; 1197| 19| } 1198| 451k| ++p; 1199| 451k| ++start; 1200| 451k| --n; 1201| 451k| } 1202| 453k| } 1203| | 1204| 727k| value.resize(n); 1205| 727k| ++it; 1206| 727k| } 1207| 957| else { 1208| | // For large inputs this case of running out of buffer is very rare 1209| 957| value.resize(n); 1210| 957| auto* p = value.data(); 1211| | 1212| 957| it = start; 1213| 6.29M| while (it < end) [[likely]] { ------------------ | Branch (1213:29): [True: 6.29M, False: 0] ------------------ 1214| 6.29M| if (*it == '"') { ------------------ | Branch (1214:29): [True: 424, False: 6.29M] ------------------ 1215| 424| value.resize(size_t(p - value.data())); 1216| 424| ++it; 1217| 424| return; 1218| 424| } 1219| | 1220| 6.29M| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1220:29): [True: 381, False: 6.29M] ------------------ 1221| 381| ctx.error = error_code::syntax_error; 1222| 381| return; 1223| 381| } 1224| | 1225| 6.29M| *p = *it; 1226| | 1227| 6.29M| if (*it == '\\') { ------------------ | Branch (1227:29): [True: 56.6k, False: 6.23M] ------------------ 1228| 56.6k| ++it; // skip the escape 1229| 56.6k| if (*it == 'u') { ------------------ | Branch (1229:32): [True: 1.46k, False: 55.2k] ------------------ 1230| 1.46k| ++it; 1231| 1.46k| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1231:35): [True: 127, False: 1.33k] ------------------ 1232| 127| ctx.error = error_code::unicode_escape_conversion_failure; 1233| 127| return; 1234| 127| } 1235| 1.46k| } 1236| 55.2k| else { 1237| 55.2k| *p = char_unescape_table[uint8_t(*it)]; 1238| 55.2k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1238:35): [True: 25, False: 55.1k] ------------------ 1239| 25| ctx.error = error_code::invalid_escape; 1240| 25| return; 1241| 25| } 1242| 55.1k| ++p; 1243| 55.1k| ++it; 1244| 55.1k| } 1245| 56.6k| } 1246| 6.23M| else { 1247| 6.23M| ++it; 1248| 6.23M| ++p; 1249| 6.23M| } 1250| 6.29M| } 1251| | 1252| 0| ctx.error = error_code::unexpected_end; 1253| 0| } 1254| 737k| } 1255| 399| else { 1256| | // For short strings 1257| | 1258| 399| std::array buffer{}; 1259| | 1260| 399| auto* p = buffer.data(); 1261| 399| const auto* const utf8_start = it; 1262| | 1263| 881| while (it < end) [[likely]] { ------------------ | Branch (1263:26): [True: 783, False: 98] ------------------ 1264| 783| *p = *it; 1265| 783| if (*it == '"') { ------------------ | Branch (1265:26): [True: 251, False: 532] ------------------ 1266| 251| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1266:29): [True: 0, False: 251] ------------------ 1267| 0| return; 1268| 0| } 1269| 251| const size_t n = size_t(p - buffer.data()); 1270| 251|#if __has_cpp_attribute(assume) >= 202207L 1271| 251| [[assume(n <= sizeof(buffer))]]; 1272| 251|#endif 1273| 251| value.assign(buffer.data(), n); 1274| 251| ++it; 1275| 251| if constexpr (not Opts.null_terminated) { 1276| 251| if (it == end) { ------------------ | Branch (1276:32): [True: 165, False: 86] ------------------ 1277| 165| ctx.error = error_code::end_reached; 1278| 165| return; 1279| 165| } 1280| 251| } 1281| 86| return; 1282| 251| } 1283| 532| else if (*it == '\\') { ------------------ | Branch (1283:31): [True: 119, False: 413] ------------------ 1284| 119| ++it; // skip the escape 1285| 119| if constexpr (not Opts.null_terminated) { 1286| 119| if (it == end) [[unlikely]] { ------------------ | Branch (1286:32): [True: 0, False: 119] ------------------ 1287| 0| ctx.error = error_code::unexpected_end; 1288| 0| return; 1289| 0| } 1290| 119| } 1291| 119| if (*it == 'u') { ------------------ | Branch (1291:29): [True: 69, False: 50] ------------------ 1292| 69| ++it; 1293| 69| if constexpr (not Opts.null_terminated) { 1294| 69| if (it == end) [[unlikely]] { ------------------ | Branch (1294:35): [True: 0, False: 69] ------------------ 1295| 0| ctx.error = error_code::unexpected_end; 1296| 0| return; 1297| 0| } 1298| 69| } 1299| 69| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1299:32): [True: 18, False: 51] ------------------ 1300| 18| ctx.error = error_code::unicode_escape_conversion_failure; 1301| 18| return; 1302| 18| } 1303| 69| } 1304| 50| else { 1305| 50| *p = char_unescape_table[uint8_t(*it)]; 1306| 50| if (*p == 0) [[unlikely]] { ------------------ | Branch (1306:32): [True: 7, False: 43] ------------------ 1307| 7| ctx.error = error_code::invalid_escape; 1308| 7| return; 1309| 7| } 1310| 43| ++p; 1311| 43| ++it; 1312| 43| } 1313| 119| } 1314| 413| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1314:31): [True: 25, False: 388] ------------------ 1315| 25| ctx.error = error_code::syntax_error; 1316| 25| return; 1317| 25| } 1318| 388| else { 1319| 388| ++it; 1320| 388| ++p; 1321| 388| } 1322| 783| } 1323| | 1324| 98| ctx.error = error_code::unexpected_end; 1325| 98| } 1326| | } 1327| | else { 1328| | // raw_string 1329| | auto start = it; 1330| | skip_string_view(ctx, it, end); 1331| | if (bool(ctx.error)) [[unlikely]] 1332| | return; 1333| | 1334| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1335| | return; 1336| | } 1337| | 1338| | value.assign(start, size_t(it - start)); 1339| | ++it; 1340| | } 1341| 752k| } 1342| 752k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav: 484| 755| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 755| { 312| 755| static constexpr auto Key = get(reflect::keys); 313| 755| static constexpr auto KeyWithEndQuote = join_v>; 314| 755| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 755| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 751, False: 4] | Branch (316:36): [True: 721, False: 30] ------------------ 317| 721| it += Length; 318| 721| if constexpr (not Opts.null_terminated) { 319| 721| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 721] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 721| } 324| | 325| 721| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 721] ------------------ 326| 0| return; 327| 0| } 328| 721| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 41, False: 680] ------------------ 329| 41| return; 330| 41| } 331| 680| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 680] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 680| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 680| } 338| 34| else [[unlikely]] { 339| 34| decode_index_unknown_key(value, ctx, it, end); 340| 34| } 341| 755| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 680| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 680| else { 273| 680| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 680| else { 297| 680| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 680| it, end); 299| 680| } 300| 680| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 680| } _ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 680| { 3045| 680| static constexpr auto num_members = reflect::size; 3046| | 3047| 680| static constexpr auto Opts = opening_handled_off()>(); 3048| 680| if constexpr (!check_opening_handled(Options)) { 3049| | if constexpr (!check_ws_handled(Options)) { 3050| | if (skip_ws(ctx, it, end)) { 3051| | return; 3052| | } 3053| | } 3054| 680| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 36, False: 644] ------------------ 3055| 36| return; 3056| 36| } 3057| 644| if constexpr (not Opts.null_terminated) { 3058| 644| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 644] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 644| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 644| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 644] ------------------ 3066| 0| return; 3067| 0| } 3068| 644| } 3069| 644| const auto ws_start = it; 3070| 680| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 680] ------------------ 3071| 0| return; 3072| 0| } 3073| 680| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 680| else { 3148| 680| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 680| if constexpr ((glaze_object_t || reflectable) && 3150| 680| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 680| return bit_array{}; 3152| 680| } 3153| 680| else { 3154| 680| return nullptr; 3155| 680| } 3156| 680| }(); 3157| | 3158| 680| size_t read_count{}; // for partial_read 3159| | 3160| 680| bool first = true; 3161| 5.05k| while (true) { ------------------ | Branch (3161:20): [True: 4.52k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 4.52k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 128, False: 4.39k] ------------------ 3199| 128| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 128| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 128| } 3224| 128| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 128| if constexpr (not Opts.null_terminated) { 3226| 128| if (it == end) { ------------------ | Branch (3226:26): [True: 0, False: 128] ------------------ 3227| 0| ctx.error = error_code::end_reached; 3228| 0| return; 3229| 0| } 3230| 128| } 3231| 128| return; 3232| 128| } 3233| 4.39k| else if (first) { ------------------ | Branch (3233:25): [True: 600, False: 3.79k] ------------------ 3234| 600| first = false; 3235| 600| } 3236| 3.79k| else { 3237| 3.79k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 25, False: 3.77k] ------------------ 3238| 25| return; 3239| 25| } 3240| 3.77k| if constexpr (not Opts.null_terminated) { 3241| 3.77k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 3.77k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 3.77k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 3.77k| (!Opts.comments)) { 3249| 3.77k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 3.56k, False: 210] | Branch (3249:37): [True: 2.57k, False: 986] ------------------ 3250| 2.57k| skip_matching_ws(ws_start, it, ws_size); 3251| 2.57k| } 3252| 3.77k| } 3253| | 3254| 3.77k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 3.77k] ------------------ 3255| 0| return; 3256| 0| } 3257| 3.77k| } 3258| | 3259| 4.37k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 4.37k| else if constexpr (reflection_type) { 3324| 4.37k| static_assert(bool(hash_info.type)); 3325| | 3326| 4.37k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 452, False: 3.91k] ------------------ 3327| 452| ctx.error = error_code::expected_quote; 3328| 452| return; 3329| 452| } 3330| 3.91k| ++it; 3331| 3.91k| if constexpr (not Opts.null_terminated) { 3332| 3.91k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 3.91k] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 3.91k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 3.91k| else { 3386| 3.91k| parse_and_invoke(value, ctx, it, end); 3387| 3.91k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 39, False: 3.87k] ------------------ 3388| 39| return; 3389| 3.91k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 4.37k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 4.37k] ------------------ 3499| 0| return; 3500| 0| } 3501| 4.37k| } 3502| 680| } 3503| 680| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 644| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 644| else { 3154| 644| return nullptr; 3155| 644| } 3156| 644| }(); _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav: 484| 896| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 896| { 312| 896| static constexpr auto Key = get(reflect::keys); 313| 896| static constexpr auto KeyWithEndQuote = join_v>; 314| 896| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 896| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 893, False: 3] | Branch (316:36): [True: 888, False: 5] ------------------ 317| 888| it += Length; 318| 888| if constexpr (not Opts.null_terminated) { 319| 888| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 888] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 888| } 324| | 325| 888| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 888] ------------------ 326| 0| return; 327| 0| } 328| 888| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 32, False: 856] ------------------ 329| 32| return; 330| 32| } 331| 856| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 856] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 856| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 856| } 338| 8| else [[unlikely]] { 339| 8| decode_index_unknown_key(value, ctx, it, end); 340| 8| } 341| 896| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 856| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 856| else { 273| 856| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 856| else { 297| 856| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 856| it, end); 299| 856| } 300| 856| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 856| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 856| { 3045| 856| static constexpr auto num_members = reflect::size; 3046| | 3047| 856| static constexpr auto Opts = opening_handled_off()>(); 3048| 856| if constexpr (!check_opening_handled(Options)) { 3049| | if constexpr (!check_ws_handled(Options)) { 3050| | if (skip_ws(ctx, it, end)) { 3051| | return; 3052| | } 3053| | } 3054| 856| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 33, False: 823] ------------------ 3055| 33| return; 3056| 33| } 3057| 823| if constexpr (not Opts.null_terminated) { 3058| 823| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 823] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 823| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 823| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 823] ------------------ 3066| 0| return; 3067| 0| } 3068| 823| } 3069| 823| const auto ws_start = it; 3070| 856| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 856] ------------------ 3071| 0| return; 3072| 0| } 3073| 856| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 856| else { 3148| 856| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 856| if constexpr ((glaze_object_t || reflectable) && 3150| 856| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 856| return bit_array{}; 3152| 856| } 3153| 856| else { 3154| 856| return nullptr; 3155| 856| } 3156| 856| }(); 3157| | 3158| 856| size_t read_count{}; // for partial_read 3159| | 3160| 856| bool first = true; 3161| 4.70k| while (true) { ------------------ | Branch (3161:20): [True: 3.93k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 3.93k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 76, False: 3.85k] ------------------ 3199| 76| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 76| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 76| } 3224| 76| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 76| if constexpr (not Opts.null_terminated) { 3226| 76| if (it == end) { ------------------ | Branch (3226:26): [True: 0, False: 76] ------------------ 3227| 0| ctx.error = error_code::end_reached; 3228| 0| return; 3229| 0| } 3230| 76| } 3231| 76| return; 3232| 76| } 3233| 3.85k| else if (first) { ------------------ | Branch (3233:25): [True: 762, False: 3.09k] ------------------ 3234| 762| first = false; 3235| 762| } 3236| 3.09k| else { 3237| 3.09k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 11, False: 3.08k] ------------------ 3238| 11| return; 3239| 11| } 3240| 3.08k| if constexpr (not Opts.null_terminated) { 3241| 3.08k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 3.08k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 3.08k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 3.08k| (!Opts.comments)) { 3249| 3.08k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 2.59k, False: 489] | Branch (3249:37): [True: 2.48k, False: 113] ------------------ 3250| 2.48k| skip_matching_ws(ws_start, it, ws_size); 3251| 2.48k| } 3252| 3.08k| } 3253| | 3254| 3.08k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 3.08k] ------------------ 3255| 0| return; 3256| 0| } 3257| 3.08k| } 3258| | 3259| 3.84k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 3.84k| else if constexpr (reflection_type) { 3324| 3.84k| static_assert(bool(hash_info.type)); 3325| | 3326| 3.84k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 641, False: 3.20k] ------------------ 3327| 641| ctx.error = error_code::expected_quote; 3328| 641| return; 3329| 641| } 3330| 3.20k| ++it; 3331| 3.20k| if constexpr (not Opts.null_terminated) { 3332| 3.20k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 3.20k] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 3.20k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 3.20k| else { 3386| 3.20k| parse_and_invoke(value, ctx, it, end); 3387| 3.20k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 95, False: 3.11k] ------------------ 3388| 95| return; 3389| 3.20k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 3.84k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 3.84k] ------------------ 3499| 0| return; 3500| 0| } 3501| 3.84k| } 3502| 856| } 3503| 856| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 823| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 823| else { 3154| 823| return nullptr; 3155| 823| } 3156| 823| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 376| 13.8k| { 377| 13.8k| constexpr auto N = reflect::size; 378| | 379| | if constexpr (N == 1) { 380| | decode_index(value, ctx, it, end, selected_index...); 381| | } 382| | else if constexpr (check_linear_search(Opts)) { 383| | // Linear search path 384| | auto key_start = it; 385| | const auto index = decode_linear(ctx, it, end); 386| | if (bool(ctx.error)) [[unlikely]] 387| | return; 388| | 389| | if (index >= N) [[unlikely]] { 390| | if constexpr (Opts.error_on_unknown_keys) { 391| | ctx.error = error_code::unknown_key; 392| | return; 393| | } 394| | else { 395| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 396| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 397| | return; 398| | } 399| | const sv key{key_start, size_t(it - key_start - 1)}; 400| | if constexpr (not Opts.null_terminated) { 401| | if (it == end) [[unlikely]] { 402| | ctx.error = error_code::unexpected_end; 403| | return; 404| | } 405| | } 406| | if (parse_ws_colon(ctx, it, end)) { 407| | return; 408| | } 409| | parse::handle_unknown(key, value, ctx, it, end); 410| | return; 411| | } 412| | } 413| | 414| | if constexpr (not Opts.null_terminated) { 415| | if (it == end) [[unlikely]] { 416| | ctx.error = error_code::unexpected_end; 417| | return; 418| | } 419| | } 420| | if (skip_ws(ctx, it, end)) { 421| | return; 422| | } 423| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 424| | return; 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | 430| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 431| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 432| | // instantiations; the whitespace before the value has already been skipped either way. 433| | [&](std::index_sequence) { 434| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 435| | : false) || 436| | ...)); 437| | }(std::make_index_sequence{}); 438| | } 439| 13.8k| else { 440| | // Hash-based lookup 441| 13.8k| constexpr auto& HashInfo = hash_info; 442| 13.8k| constexpr auto type = HashInfo.type; 443| 13.8k| static_assert(bool(type), "invalid hash algorithm"); 444| | 445| 13.8k| const auto index = decode_hash::op(it, end); 446| | 447| 13.8k| if (index >= N) [[unlikely]] { ------------------ | Branch (447:14): [True: 0, False: 13.8k] ------------------ 448| 0| if constexpr (Opts.error_on_unknown_keys) { 449| 0| ctx.error = error_code::unknown_key; 450| 0| return; 451| | } 452| | else { 453| | auto start = it; 454| | skip_string_view(ctx, it, end); 455| | if (bool(ctx.error)) [[unlikely]] 456| | return; 457| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 458| | return; 459| | const sv key = {start, size_t(it - start)}; 460| | ++it; // skip the quote 461| | if constexpr (not Opts.null_terminated) { 462| | if (it == end) [[unlikely]] { 463| | ctx.error = error_code::unexpected_end; 464| | return; 465| | } 466| | } 467| | if (parse_ws_colon(ctx, it, end)) { 468| | return; 469| | } 470| | parse::handle_unknown(key, value, ctx, it, end); 471| | return; 472| | } 473| 0| } 474| | 475| 13.8k| if constexpr (N == 2) { 476| 13.8k| if (index == 0) { ------------------ | Branch (476:17): [True: 12.8k, False: 949] ------------------ 477| 12.8k| decode_index(value, ctx, it, end, selected_index...); 478| 12.8k| } 479| 949| else { 480| 949| decode_index(value, ctx, it, end, selected_index...); 481| 949| } 482| | } 483| | else { 484| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 485| | } 486| 13.8k| } 487| 13.8k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 12.8k| { 312| 12.8k| static constexpr auto Key = get(reflect::keys); 313| 12.8k| static constexpr auto KeyWithEndQuote = join_v>; 314| 12.8k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 12.8k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 12.8k, False: 13] | Branch (316:36): [True: 12.8k, False: 22] ------------------ 317| 12.8k| it += Length; 318| 12.8k| if constexpr (not Opts.null_terminated) { 319| 12.8k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 12.8k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 12.8k| } 324| | 325| 12.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 12.8k] ------------------ 326| 0| return; 327| 0| } 328| 12.8k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 36, False: 12.8k] ------------------ 329| 36| return; 330| 36| } 331| 12.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 12.8k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 12.8k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 12.8k| } 338| 35| else [[unlikely]] { 339| 35| decode_index_unknown_key(value, ctx, it, end); 340| 35| } 341| 12.8k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 12.8k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 12.8k| else { 273| 12.8k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 12.8k| else { 297| 12.8k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 12.8k| it, end); 299| 12.8k| } 300| 12.8k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 12.8k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 92| { 178| 92| if constexpr (Opts.error_on_unknown_keys) { 179| 92| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 92| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 949| { 312| 949| static constexpr auto Key = get(reflect::keys); 313| 949| static constexpr auto KeyWithEndQuote = join_v>; 314| 949| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 949| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 927, False: 22] | Branch (316:36): [True: 892, False: 35] ------------------ 317| 892| it += Length; 318| 892| if constexpr (not Opts.null_terminated) { 319| 892| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 892] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 892| } 324| | 325| 892| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 892] ------------------ 326| 0| return; 327| 0| } 328| 892| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 75, False: 817] ------------------ 329| 75| return; 330| 75| } 331| 817| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 817] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 817| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 817| } 338| 57| else [[unlikely]] { 339| 57| decode_index_unknown_key(value, ctx, it, end); 340| 57| } 341| 949| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 817| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 817| else { 273| 817| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 817| else { 297| 817| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 817| it, end); 299| 817| } 300| 817| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 817| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm4EEEDav: 484| 6.95k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 6.95k| { 312| 6.95k| static constexpr auto Key = get(reflect::keys); 313| 6.95k| static constexpr auto KeyWithEndQuote = join_v>; 314| 6.95k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 6.95k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 6.94k, False: 7] | Branch (316:36): [True: 6.93k, False: 11] ------------------ 317| 6.93k| it += Length; 318| 6.93k| if constexpr (not Opts.null_terminated) { 319| 6.93k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 6.93k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 6.93k| } 324| | 325| 6.93k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 6.93k] ------------------ 326| 0| return; 327| 0| } 328| 6.93k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 20, False: 6.91k] ------------------ 329| 20| return; 330| 20| } 331| 6.91k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 6.91k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 6.91k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 6.91k| } 338| 18| else [[unlikely]] { 339| 18| decode_index_unknown_key(value, ctx, it, end); 340| 18| } 341| 6.95k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 6.91k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 6.91k| else { 273| 6.91k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 6.91k| else { 297| 6.91k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 6.91k| it, end); 299| 6.91k| } 300| 6.91k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 6.91k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2308| 6.91k| { 2309| 6.91k| constexpr auto Opts = ws_handled_off(); 2310| | if constexpr (!check_ws_handled(Options)) { 2311| | if (skip_ws(ctx, it, end)) { 2312| | return; 2313| | } 2314| | } 2315| | 2316| 6.91k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2316:14): [True: 31, False: 6.88k] ------------------ 2317| 31| return; 2318| 31| } 2319| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2320| | // released at each syntactic close below 2321| 6.88k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2321:14): [True: 0, False: 6.88k] ------------------ 2322| 0| return; 2323| 0| } 2324| | 2325| 6.88k| const auto ws_start = it; 2326| 6.88k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2326:14): [True: 0, False: 6.88k] ------------------ 2327| 0| return; 2328| 0| } 2329| | 2330| 6.88k| if (*it == ']') { ------------------ | Branch (2330:14): [True: 310, False: 6.57k] ------------------ 2331| 310| --ctx.depth; 2332| 310| ++it; 2333| 310| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2334| 310| value.clear(); 2335| | 2336| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2337| | value.shrink_to_fit(); 2338| | } 2339| 310| } 2340| 310| return; 2341| 310| } 2342| | 2343| 6.57k| const size_t ws_size = size_t(it - ws_start); 2344| | 2345| 6.57k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2345:49): [True: 6.57k, Folded] | Branch (2345:65): [Folded, False: 0] | Branch (2345:90): [Folded, False: 0] ------------------ 2346| 6.57k| if constexpr (not should_append) { 2347| 6.57k| const auto n = value.size(); 2348| | 2349| 6.57k| auto value_it = value.begin(); 2350| | 2351| 75.2k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2351:32): [True: 70.8k, False: 4.40k] ------------------ 2352| 70.8k| parse::op()>(*value_it++, ctx, it, end); 2353| 70.8k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2353:20): [True: 377, False: 70.4k] ------------------ 2354| 377| return; 2355| 70.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2355:20): [True: 0, False: 70.4k] ------------------ 2356| 0| return; 2357| 0| } 2358| 70.4k| if (*it == ',') { ------------------ | Branch (2358:20): [True: 68.6k, False: 1.79k] ------------------ 2359| 68.6k| ++it; 2360| | 2361| 68.6k| if constexpr (!Opts.minified && !Opts.comments) { 2362| 68.6k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2362:26): [True: 61.7k, False: 6.90k] | Branch (2362:37): [True: 61.5k, False: 236] ------------------ 2363| 61.5k| skip_matching_ws(ws_start, it, ws_size); 2364| 61.5k| } 2365| 68.6k| } 2366| | 2367| 68.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:23): [True: 0, False: 68.6k] ------------------ 2368| 0| return; 2369| 0| } 2370| 68.6k| } 2371| 1.79k| else if (*it == ']') { ------------------ | Branch (2371:25): [True: 1.51k, False: 282] ------------------ 2372| 1.51k| --ctx.depth; 2373| 1.51k| ++it; 2374| 1.51k| if constexpr (erasable) { 2375| 1.51k| value.erase(value_it, 2376| 1.51k| value.end()); // use erase rather than resize for non-default constructible elements 2377| | 2378| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2379| | value.shrink_to_fit(); 2380| | } 2381| 1.51k| } 2382| 1.51k| return; 2383| 1.51k| } 2384| 282| else [[unlikely]] { 2385| 282| ctx.error = error_code::expected_bracket; 2386| 282| return; 2387| 282| } 2388| 70.4k| } 2389| 6.57k| } 2390| | 2391| | if constexpr (Opts.partial_read) { 2392| | // partial_read stops early on a success path, so give the level back like the 2393| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2394| | --ctx.depth; 2395| | return; 2396| | } 2397| 6.57k| else { 2398| | // growing 2399| 6.57k| if constexpr (emplace_backable || has_try_emplace_back) { 2400| 146k| while (it < end) { ------------------ | Branch (2400:23): [True: 144k, False: 2.17k] ------------------ 2401| | // Streaming refill point: at start of each iteration, ensure buffer has data 2402| | if constexpr (has_streaming_state) { 2403| | if (ctx.stream.enabled()) { 2404| | const size_t consumed = static_cast(it - ctx.stream.data()); 2405| | const size_t remaining = ctx.stream.size() - consumed; 2406| | // Refill when less than half of buffer remains to ensure space for next element 2407| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2408| | const char* new_it; 2409| | const char* new_end; 2410| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2411| | it = new_it; 2412| | end = new_end; 2413| | if (it >= end && ctx.stream.at_eof()) { 2414| | break; // No more data, exit loop normally 2415| | } 2416| | } 2417| | } 2418| | } 2419| | 2420| | if constexpr (has_try_emplace_back) { 2421| | if (value.try_emplace_back()) 2422| | parse::op()>(value.back(), ctx, it, end); 2423| | else 2424| | ctx.error = error_code::exceeded_static_array_size; 2425| | } 2426| 144k| else { 2427| 144k| parse::op()>(value.emplace_back(), ctx, it, end); 2428| 144k| } 2429| | 2430| 144k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2430:23): [True: 1.05k, False: 142k] ------------------ 2431| 1.05k| return; 2432| | 2433| | // Streaming refill point: after parsing each element, refill if buffer is low 2434| | if constexpr (has_streaming_state) { 2435| | if (ctx.stream.enabled()) { 2436| | const size_t consumed = static_cast(it - ctx.stream.data()); 2437| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2438| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2439| | const char* new_it; 2440| | const char* new_end; 2441| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2442| | it = new_it; 2443| | end = new_end; 2444| | if (it >= end && ctx.stream.at_eof()) { 2445| | ctx.error = error_code::unexpected_end; 2446| | return; 2447| | } 2448| | } 2449| | } 2450| | } 2451| | 2452| 142k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2452:23): [True: 0, False: 142k] ------------------ 2453| 0| return; 2454| 0| } 2455| 142k| if (*it == ',') [[likely]] { ------------------ | Branch (2455:23): [True: 139k, False: 3.34k] ------------------ 2456| 139k| ++it; 2457| | 2458| 139k| if constexpr (!Opts.minified && !Opts.comments) { 2459| 139k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2459:29): [True: 126k, False: 12.9k] | Branch (2459:40): [True: 126k, False: 381] ------------------ 2460| 126k| skip_matching_ws(ws_start, it, ws_size); 2461| 126k| } 2462| 139k| } 2463| | 2464| 139k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2464:26): [True: 0, False: 139k] ------------------ 2465| 0| return; 2466| 0| } 2467| 139k| } 2468| 3.34k| else if (*it == ']') { ------------------ | Branch (2468:28): [True: 2.79k, False: 557] ------------------ 2469| 2.79k| --ctx.depth; 2470| 2.79k| ++it; 2471| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2472| | value.shrink_to_fit(); 2473| | } 2474| 2.79k| return; 2475| 2.79k| } 2476| 557| else [[unlikely]] { 2477| 557| ctx.error = error_code::expected_bracket; 2478| 557| return; 2479| 557| } 2480| 142k| } 2481| | 2482| | // A valid array always returns from inside the loop upon reaching ']'. 2483| | // For a null-terminated buffer the loop can only exit here by falling 2484| | // through when `it` reaches the terminator without a closing bracket, 2485| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2486| | // Non-null-terminated buffers surface this through skip_ws/depth 2487| | // tracking (or the streaming refill break), so this guard is limited 2488| | // to the null-terminated case. 2489| | if constexpr (Opts.null_terminated) { 2490| | ctx.error = error_code::unexpected_end; 2491| | } 2492| | } 2493| | else { 2494| | ctx.error = error_code::exceeded_static_array_size; 2495| | } 2496| 6.57k| } 2497| 6.57k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 829k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 829k| else { 60| 829k| using V = std::remove_cvref_t; 61| 829k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 829k| end); 63| 829k| } 64| 829k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm5EEEDav: 484| 1.20k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 1.20k| { 312| 1.20k| static constexpr auto Key = get(reflect::keys); 313| 1.20k| static constexpr auto KeyWithEndQuote = join_v>; 314| 1.20k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 1.20k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 1.20k, False: 4] | Branch (316:36): [True: 1.19k, False: 5] ------------------ 317| 1.19k| it += Length; 318| 1.19k| if constexpr (not Opts.null_terminated) { 319| 1.19k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 1.19k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 1.19k| } 324| | 325| 1.19k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 1.19k] ------------------ 326| 0| return; 327| 0| } 328| 1.19k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 26, False: 1.17k] ------------------ 329| 26| return; 330| 26| } 331| 1.17k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 1.17k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 1.17k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 1.17k| } 338| 9| else [[unlikely]] { 339| 9| decode_index_unknown_key(value, ctx, it, end); 340| 9| } 341| 1.20k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 1.17k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 1.17k| else { 273| 1.17k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 1.17k| else { 297| 1.17k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 1.17k| it, end); 299| 1.17k| } 300| 1.17k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 1.17k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 3044| 1.17k| { 3045| 1.17k| static constexpr auto num_members = reflect::size; 3046| | 3047| 1.17k| static constexpr auto Opts = opening_handled_off()>(); 3048| 1.17k| if constexpr (!check_opening_handled(Options)) { 3049| | if constexpr (!check_ws_handled(Options)) { 3050| | if (skip_ws(ctx, it, end)) { 3051| | return; 3052| | } 3053| | } 3054| 1.17k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 35, False: 1.13k] ------------------ 3055| 35| return; 3056| 35| } 3057| 1.13k| if constexpr (not Opts.null_terminated) { 3058| 1.13k| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 1.13k] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 1.13k| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 1.13k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 1.13k] ------------------ 3066| 0| return; 3067| 0| } 3068| 1.13k| } 3069| 1.13k| const auto ws_start = it; 3070| 1.17k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 1.17k] ------------------ 3071| 0| return; 3072| 0| } 3073| 1.17k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 1.17k| else { 3148| 1.17k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 1.17k| if constexpr ((glaze_object_t || reflectable) && 3150| 1.17k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 1.17k| return bit_array{}; 3152| 1.17k| } 3153| 1.17k| else { 3154| 1.17k| return nullptr; 3155| 1.17k| } 3156| 1.17k| }(); 3157| | 3158| 1.17k| size_t read_count{}; // for partial_read 3159| | 3160| 1.17k| bool first = true; 3161| 18.4k| while (true) { ------------------ | Branch (3161:20): [True: 17.7k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 17.7k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 360, False: 17.4k] ------------------ 3199| 360| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| | if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| | } 3224| 360| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 360| if constexpr (not Opts.null_terminated) { 3226| 360| if (it == end) { ------------------ | Branch (3226:26): [True: 0, False: 360] ------------------ 3227| 0| ctx.error = error_code::end_reached; 3228| 0| return; 3229| 0| } 3230| 360| } 3231| 360| return; 3232| 360| } 3233| 17.4k| else if (first) { ------------------ | Branch (3233:25): [True: 1.02k, False: 16.4k] ------------------ 3234| 1.02k| first = false; 3235| 1.02k| } 3236| 16.4k| else { 3237| 16.4k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 196, False: 16.2k] ------------------ 3238| 196| return; 3239| 196| } 3240| 16.2k| if constexpr (not Opts.null_terminated) { 3241| 16.2k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 16.2k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 16.2k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| | (!Opts.comments)) { 3249| | if (ws_size && ws_size < size_t(end - it)) { 3250| | skip_matching_ws(ws_start, it, ws_size); 3251| | } 3252| | } 3253| | 3254| 16.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 16.2k] ------------------ 3255| 0| return; 3256| 0| } 3257| 16.2k| } 3258| | 3259| 17.2k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [Folded, False: 0] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| | else if constexpr (reflection_type) { 3324| | static_assert(bool(hash_info.type)); 3325| | 3326| | if (*it != '"') [[unlikely]] { 3327| | ctx.error = error_code::expected_quote; 3328| | return; 3329| | } 3330| | ++it; 3331| | if constexpr (not Opts.null_terminated) { 3332| | if (it == end) [[unlikely]] { 3333| | ctx.error = error_code::unexpected_end; 3334| | return; 3335| | } 3336| | } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| | else { 3386| | parse_and_invoke(value, ctx, it, end); 3387| | if (bool(ctx.error)) [[unlikely]] 3388| | return; 3389| | } 3390| | } 3391| 17.2k| else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| 17.2k| auto reading = [&](auto&& key) { 3395| 17.2k| if constexpr (Opts.partial_read) { 3396| 17.2k| if (auto element = value.find(key); element != value.end()) { 3397| 17.2k| ++read_count; 3398| 17.2k| parse::op()>(element->second, ctx, it, end); 3399| 17.2k| } 3400| 17.2k| else { 3401| 17.2k| skip_value::op(ctx, it, end); 3402| 17.2k| } 3403| 17.2k| } 3404| 17.2k| else { 3405| 17.2k| parse::op()>(value[key], ctx, it, end); 3406| 17.2k| } 3407| 17.2k| }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| 17.2k| using Key = typename T::key_type; 3411| 17.2k| if constexpr (std::is_same_v) { 3412| 17.2k| ctx.scratch.clear(); 3413| 17.2k| parse::op(ctx.scratch, ctx, it, end); 3414| 17.2k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3414:26): [True: 134, False: 17.0k] ------------------ 3415| 134| return; 3416| | 3417| 17.0k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3417:26): [True: 66, False: 17.0k] ------------------ 3418| 66| return; 3419| 66| } 3420| | 3421| 17.0k| reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| 17.0k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 382, False: 16.6k] ------------------ 3428| 382| return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| 17.2k| } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 17.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 17.2k] ------------------ 3499| 0| return; 3500| 0| } 3501| 17.2k| } 3502| 1.17k| } 3503| 1.17k| } _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 1.13k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 1.13k| else { 3154| 1.13k| return nullptr; 3155| 1.13k| } 3156| 1.13k| }(); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 1.52M| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.52M| else { 60| 1.52M| using V = std::remove_cvref_t; 61| 1.52M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.52M| end); 63| 1.52M| } 64| 1.52M| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_: 1043| 1.52M| { 1044| | if constexpr (check_string_as_number(Opts)) { 1045| | auto start = it; 1046| | skip_number(ctx, it, end); 1047| | if (bool(ctx.error)) [[unlikely]] { 1048| | return; 1049| | } 1050| | if (start == it) [[unlikely]] { 1051| | ctx.error = error_code::parse_number_failure; 1052| | return; 1053| | } 1054| | value.append(start, size_t(it - start)); 1055| | } 1056| 1.52M| else { 1057| 1.52M| if constexpr (!check_opening_handled(Opts)) { 1058| 1.52M| if constexpr (!check_ws_handled(Opts)) { 1059| 1.52M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (1059:23): [True: 0, False: 1.52M] ------------------ 1060| 0| return; 1061| 0| } 1062| 1.52M| } 1063| | 1064| 1.52M| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1064:20): [True: 585, False: 1.52M] ------------------ 1065| 585| return; 1066| 585| } 1067| 1.52M| } 1068| | 1069| 1.52M| if constexpr (not check_raw_string(Opts)) { 1070| 1.52M| static constexpr auto string_padding_bytes = 8; 1071| | 1072| 1.52M| if (size_t(end - it) >= 8) { ------------------ | Branch (1072:20): [True: 1.50M, False: 17.1k] ------------------ 1073| 1.50M| auto start = it; 1074| 1.50M| uint64_t ascii_acc{}; 1075| 1.50M| const auto end8 = end - 8; 1076| 4.68M| while (true) { ------------------ | Branch (1076:26): [True: 4.68M, Folded] ------------------ 1077| 4.68M| if (it >= end8) [[unlikely]] { ------------------ | Branch (1077:26): [True: 978, False: 4.68M] ------------------ 1078| 978| break; 1079| 978| } 1080| | 1081| 4.68M| uint64_t chunk; 1082| 4.68M| std::memcpy(&chunk, it, 8); 1083| | if constexpr (std::endian::native == std::endian::big) { 1084| | chunk = std::byteswap(chunk); 1085| | } 1086| 4.68M| ascii_acc |= chunk; 1087| 4.68M| const uint64_t test_chars = has_quote(chunk); 1088| 4.68M| if (test_chars) { ------------------ | Branch (1088:26): [True: 1.50M, False: 3.17M] ------------------ 1089| 1.50M| it += (countr_zero(test_chars) >> 3); 1090| | 1091| 1.50M| auto* prev = it - 1; 1092| 1.51M| while (*prev == '\\') { ------------------ | Branch (1092:32): [True: 12.0k, False: 1.50M] ------------------ 1093| 12.0k| --prev; 1094| 12.0k| } 1095| 1.50M| if (size_t(it - prev) % 2) { ------------------ | Branch (1095:29): [True: 1.50M, False: 2.62k] ------------------ 1096| 1.50M| goto continue_decode; 1097| 1.50M| } 1098| 2.62k| ++it; // skip the escaped quote 1099| 2.62k| } 1100| 3.17M| else { 1101| 3.17M| it += 8; 1102| 3.17M| } 1103| 4.68M| } 1104| | 1105| 2.32k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (1105:26): [True: 1.34k, False: 978] ------------------ 1106| | // if we ended on an escape character then we need to rewind 1107| | // because we lost our context 1108| 1.34k| --it; 1109| 1.34k| } 1110| | 1111| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 1112| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 1113| 5.32k| for (; it < end; ++it) { ------------------ | Branch (1113:26): [True: 5.32k, False: 0] ------------------ 1114| 5.32k| ascii_acc |= uint8_t(*it); 1115| 5.32k| if (*it == '"') { ------------------ | Branch (1115:26): [True: 1.01k, False: 4.30k] ------------------ 1116| 1.01k| auto* prev = it - 1; 1117| 2.28k| while (*prev == '\\') { ------------------ | Branch (1117:32): [True: 1.26k, False: 1.01k] ------------------ 1118| 1.26k| --prev; 1119| 1.26k| } 1120| 1.01k| if (size_t(it - prev) % 2) { ------------------ | Branch (1120:29): [True: 978, False: 39] ------------------ 1121| 978| goto continue_decode; 1122| 978| } 1123| 1.01k| } 1124| 5.32k| } 1125| | 1126| 0| ctx.error = error_code::unexpected_end; 1127| 0| return; 1128| | 1129| 1.50M| continue_decode: 1130| | 1131| 1.50M| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1131:23): [True: 0, False: 1.50M] ------------------ 1132| 0| return; 1133| 0| } 1134| | 1135| 1.50M| const auto available_padding = size_t(end - it); 1136| 1.50M| auto n = size_t(it - start); 1137| 1.50M| if (available_padding >= 8) [[likely]] { ------------------ | Branch (1137:23): [True: 1.48M, False: 20.2k] ------------------ 1138| 1.48M| value.resize(n + string_padding_bytes); 1139| | 1140| 1.48M| auto* p = value.data(); 1141| | 1142| 3.72M| while (true) { ------------------ | Branch (1142:29): [True: 3.72M, Folded] ------------------ 1143| 3.72M| if (start >= it) { ------------------ | Branch (1143:29): [True: 1.48M, False: 2.24M] ------------------ 1144| 1.48M| break; 1145| 1.48M| } 1146| | 1147| 2.24M| std::memcpy(p, start, 8); 1148| 2.24M| uint64_t swar; 1149| 2.24M| std::memcpy(&swar, p, 8); 1150| | if constexpr (std::endian::native == std::endian::big) { 1151| | swar = std::byteswap(swar); 1152| | } 1153| | 1154| 2.24M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1155| 2.24M| const uint64_t lo7 = swar & lo7_mask; 1156| 2.24M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1157| 2.24M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1158| 2.24M| uint64_t next = ~((backslash & less_32) | swar); 1159| | 1160| 2.24M| next &= repeat_byte8(0b10000000); 1161| 2.24M| if (next == 0) { ------------------ | Branch (1161:29): [True: 2.23M, False: 14.5k] ------------------ 1162| 2.23M| start += 8; 1163| 2.23M| p += 8; 1164| 2.23M| continue; 1165| 2.23M| } 1166| | 1167| 14.5k| next = countr_zero(next) >> 3; 1168| 14.5k| start += next; 1169| 14.5k| if (start >= it) { ------------------ | Branch (1169:29): [True: 4.25k, False: 10.3k] ------------------ 1170| 4.25k| break; 1171| 4.25k| } 1172| | 1173| 10.3k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1173:29): [True: 34, False: 10.3k] ------------------ 1174| 34| ctx.error = error_code::syntax_error; 1175| 34| return; 1176| 34| } 1177| 10.3k| ++start; // skip the escape 1178| 10.3k| if (*start == 'u') { ------------------ | Branch (1178:29): [True: 7.57k, False: 2.73k] ------------------ 1179| 7.57k| ++start; 1180| 7.57k| p += next; 1181| 7.57k| const auto mark = start; 1182| 7.57k| const auto offset = handle_unicode_code_point(start, p, end); 1183| 7.57k| if (offset == 0) [[unlikely]] { ------------------ | Branch (1183:32): [True: 76, False: 7.49k] ------------------ 1184| 76| ctx.error = error_code::unicode_escape_conversion_failure; 1185| 76| return; 1186| 76| } 1187| 7.49k| n += offset; 1188| | // escape + u + unicode code points 1189| 7.49k| n -= 2 + uint32_t(start - mark); 1190| 7.49k| } 1191| 2.73k| else { 1192| 2.73k| p += next; 1193| 2.73k| *p = char_unescape_table[uint8_t(*start)]; 1194| 2.73k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1194:32): [True: 8, False: 2.72k] ------------------ 1195| 8| ctx.error = error_code::invalid_escape; 1196| 8| return; 1197| 8| } 1198| 2.72k| ++p; 1199| 2.72k| ++start; 1200| 2.72k| --n; 1201| 2.72k| } 1202| 10.3k| } 1203| | 1204| 1.48M| value.resize(n); 1205| 1.48M| ++it; 1206| 1.48M| } 1207| 20.2k| else { 1208| | // For large inputs this case of running out of buffer is very rare 1209| 20.2k| value.resize(n); 1210| 20.2k| auto* p = value.data(); 1211| | 1212| 20.2k| it = start; 1213| 16.5M| while (it < end) [[likely]] { ------------------ | Branch (1213:29): [True: 16.5M, False: 0] ------------------ 1214| 16.5M| if (*it == '"') { ------------------ | Branch (1214:29): [True: 19.9k, False: 16.5M] ------------------ 1215| 19.9k| value.resize(size_t(p - value.data())); 1216| 19.9k| ++it; 1217| 19.9k| return; 1218| 19.9k| } 1219| | 1220| 16.5M| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1220:29): [True: 128, False: 16.5M] ------------------ 1221| 128| ctx.error = error_code::syntax_error; 1222| 128| return; 1223| 128| } 1224| | 1225| 16.5M| *p = *it; 1226| | 1227| 16.5M| if (*it == '\\') { ------------------ | Branch (1227:29): [True: 28.8k, False: 16.4M] ------------------ 1228| 28.8k| ++it; // skip the escape 1229| 28.8k| if (*it == 'u') { ------------------ | Branch (1229:32): [True: 22.0k, False: 6.86k] ------------------ 1230| 22.0k| ++it; 1231| 22.0k| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1231:35): [True: 94, False: 21.9k] ------------------ 1232| 94| ctx.error = error_code::unicode_escape_conversion_failure; 1233| 94| return; 1234| 94| } 1235| 22.0k| } 1236| 6.86k| else { 1237| 6.86k| *p = char_unescape_table[uint8_t(*it)]; 1238| 6.86k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1238:35): [True: 39, False: 6.82k] ------------------ 1239| 39| ctx.error = error_code::invalid_escape; 1240| 39| return; 1241| 39| } 1242| 6.82k| ++p; 1243| 6.82k| ++it; 1244| 6.82k| } 1245| 28.8k| } 1246| 16.4M| else { 1247| 16.4M| ++it; 1248| 16.4M| ++p; 1249| 16.4M| } 1250| 16.5M| } 1251| | 1252| 0| ctx.error = error_code::unexpected_end; 1253| 0| } 1254| 1.50M| } 1255| 17.1k| else { 1256| | // For short strings 1257| | 1258| 17.1k| std::array buffer{}; 1259| | 1260| 17.1k| auto* p = buffer.data(); 1261| 17.1k| const auto* const utf8_start = it; 1262| | 1263| 49.1k| while (it < end) [[likely]] { ------------------ | Branch (1263:26): [True: 48.6k, False: 585] ------------------ 1264| 48.6k| *p = *it; 1265| 48.6k| if (*it == '"') { ------------------ | Branch (1265:26): [True: 16.4k, False: 32.1k] ------------------ 1266| 16.4k| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1266:29): [True: 0, False: 16.4k] ------------------ 1267| 0| return; 1268| 0| } 1269| 16.4k| const size_t n = size_t(p - buffer.data()); 1270| 16.4k|#if __has_cpp_attribute(assume) >= 202207L 1271| 16.4k| [[assume(n <= sizeof(buffer))]]; 1272| 16.4k|#endif 1273| 16.4k| value.assign(buffer.data(), n); 1274| 16.4k| ++it; 1275| 16.4k| if constexpr (not Opts.null_terminated) { 1276| 16.4k| if (it == end) { ------------------ | Branch (1276:32): [True: 167, False: 16.3k] ------------------ 1277| 167| ctx.error = error_code::end_reached; 1278| 167| return; 1279| 167| } 1280| 16.4k| } 1281| 16.3k| return; 1282| 16.4k| } 1283| 32.1k| else if (*it == '\\') { ------------------ | Branch (1283:31): [True: 128, False: 32.0k] ------------------ 1284| 128| ++it; // skip the escape 1285| 128| if constexpr (not Opts.null_terminated) { 1286| 128| if (it == end) [[unlikely]] { ------------------ | Branch (1286:32): [True: 0, False: 128] ------------------ 1287| 0| ctx.error = error_code::unexpected_end; 1288| 0| return; 1289| 0| } 1290| 128| } 1291| 128| if (*it == 'u') { ------------------ | Branch (1291:29): [True: 65, False: 63] ------------------ 1292| 65| ++it; 1293| 65| if constexpr (not Opts.null_terminated) { 1294| 65| if (it == end) [[unlikely]] { ------------------ | Branch (1294:35): [True: 0, False: 65] ------------------ 1295| 0| ctx.error = error_code::unexpected_end; 1296| 0| return; 1297| 0| } 1298| 65| } 1299| 65| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1299:32): [True: 22, False: 43] ------------------ 1300| 22| ctx.error = error_code::unicode_escape_conversion_failure; 1301| 22| return; 1302| 22| } 1303| 65| } 1304| 63| else { 1305| 63| *p = char_unescape_table[uint8_t(*it)]; 1306| 63| if (*p == 0) [[unlikely]] { ------------------ | Branch (1306:32): [True: 13, False: 50] ------------------ 1307| 13| ctx.error = error_code::invalid_escape; 1308| 13| return; 1309| 13| } 1310| 50| ++p; 1311| 50| ++it; 1312| 50| } 1313| 128| } 1314| 32.0k| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1314:31): [True: 17, False: 31.9k] ------------------ 1315| 17| ctx.error = error_code::syntax_error; 1316| 17| return; 1317| 17| } 1318| 31.9k| else { 1319| 31.9k| ++it; 1320| 31.9k| ++p; 1321| 31.9k| } 1322| 48.6k| } 1323| | 1324| 585| ctx.error = error_code::unexpected_end; 1325| 585| } 1326| | } 1327| | else { 1328| | // raw_string 1329| | auto start = it; 1330| | skip_string_view(ctx, it, end); 1331| | if (bool(ctx.error)) [[unlikely]] 1332| | return; 1333| | 1334| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1335| | return; 1336| | } 1337| | 1338| | value.assign(start, size_t(it - start)); 1339| | ++it; 1340| | } 1341| 1.52M| } 1342| 1.52M| } _ZN3glz14parse_ws_colonITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT0_OT1_T2_: 159| 1.52M| { 160| 1.52M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (160:11): [True: 0, False: 1.52M] ------------------ 161| 0| return true; 162| 0| } 163| 1.52M| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (163:11): [True: 330, False: 1.52M] ------------------ 164| 330| return true; 165| 330| } 166| 1.52M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (166:11): [True: 0, False: 1.52M] ------------------ 167| 0| return true; 168| 0| } 169| 1.52M| return false; 170| 1.52M| } _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRS8_EEDaSZ_: 3394| 17.0k| auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| 17.0k| else { 3405| 17.0k| parse::op()>(value[key], ctx, it, end); 3406| 17.0k| } 3407| 17.0k| }; _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm6EEEDav: 484| 1.44k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 1.44k| { 312| 1.44k| static constexpr auto Key = get(reflect::keys); 313| 1.44k| static constexpr auto KeyWithEndQuote = join_v>; 314| 1.44k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 1.44k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 1.43k, False: 8] | Branch (316:36): [True: 1.42k, False: 3] ------------------ 317| 1.42k| it += Length; 318| 1.42k| if constexpr (not Opts.null_terminated) { 319| 1.42k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 1.42k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 1.42k| } 324| | 325| 1.42k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 1.42k] ------------------ 326| 0| return; 327| 0| } 328| 1.42k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 22, False: 1.40k] ------------------ 329| 22| return; 330| 22| } 331| 1.40k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 1.40k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 1.40k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 1.40k| } 338| 11| else [[unlikely]] { 339| 11| decode_index_unknown_key(value, ctx, it, end); 340| 11| } 341| 1.44k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 1.40k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 1.40k| else { 273| 1.40k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 1.40k| else { 297| 1.40k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 1.40k| it, end); 299| 1.40k| } 300| 1.40k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 1.40k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 5088| 1.40k| { 5089| 1.40k| constexpr auto Opts = ws_handled_off(); 5090| | if constexpr (!check_ws_handled(Options)) { 5091| | if (skip_ws(ctx, it, end)) { 5092| | return; 5093| | } 5094| | } 5095| | 5096| 1.40k| if (*it == 'n') { ------------------ | Branch (5096:14): [True: 577, False: 830] ------------------ 5097| 577| ++it; 5098| 577| if constexpr (not Opts.null_terminated) { 5099| 577| if (it == end) [[unlikely]] { ------------------ | Branch (5099:20): [True: 0, False: 577] ------------------ 5100| 0| ctx.error = error_code::unexpected_end; 5101| 0| return; 5102| 0| } 5103| 577| } 5104| 577| match<"ull", Opts>(ctx, it, end); 5105| 577| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (5105:17): [True: 32, False: 545] ------------------ 5106| 32| return; 5107| 545| if constexpr (requires { value.reset(); }) { 5108| 545| value.reset(); 5109| 545| } 5110| 545| } 5111| 830| else { 5112| 830| if constexpr (nullable_value_t) { 5113| 830| if (not value.has_value()) { ------------------ | Branch (5113:20): [True: 429, False: 401] ------------------ 5114| | if constexpr (constructible) { 5115| | value = meta_construct_v(); 5116| | } 5117| 429| else if constexpr (requires { value.emplace(); }) { 5118| 429| value.emplace(); 5119| | } 5120| | else { 5121| | static_assert(false_v, 5122| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 5123| | "create a custom glz::from specialization"); 5124| | } 5125| 429| } 5126| 830| parse::op(value.value(), ctx, it, end); 5127| | } 5128| | else { 5129| | if (!value) { 5130| | if (!nullable_emplace(value, ctx)) { 5131| | return; 5132| | } 5133| | } 5134| | parse::op(*value, ctx, it, end); 5135| | } 5136| 830| } 5137| 1.40k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 3.52k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 3.52k| else { 60| 3.52k| using V = std::remove_cvref_t; 61| 3.52k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.52k| end); 63| 3.52k| } 64| 3.52k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 767| 3.52k| { 768| | if constexpr (check_quoted_num(Opts)) { 769| | if (skip_ws(ctx, it, end)) { 770| | return; 771| | } 772| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 773| | return; 774| | } 775| | } 776| | 777| 3.52k| if constexpr (!check_ws_handled(Opts)) { 778| 3.52k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (778:17): [True: 0, False: 3.52k] ------------------ 779| 0| return; 780| 0| } 781| 3.52k| } 782| | 783| 3.52k| using V = std::decay_t; 784| | if constexpr (int_t) { 785| | static_assert(sizeof(*it) == sizeof(char)); 786| | 787| | if constexpr (Opts.null_terminated) { 788| | if (not glz::atoi(value, it)) [[unlikely]] { 789| | ctx.error = error_code::parse_number_failure; 790| | return; 791| | } 792| | } 793| | else { 794| | if (not glz::atoi(value, it, end)) [[unlikely]] { 795| | ctx.error = error_code::parse_number_failure; 796| | return; 797| | } 798| | } 799| | } 800| 3.52k| else { 801| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 802| 3.52k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 803| | if constexpr (is_float128) { 804| | auto [ptr, ec] = std::from_chars(it, end, value); 805| | if (ec != std::errc()) { 806| | ctx.error = error_code::parse_number_failure; 807| | return; 808| | } 809| | it = ptr; 810| | } 811| | else 812| |#endif 813| 3.52k| { 814| | if constexpr (std::is_volatile_v>) { 815| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 816| | // place 817| | V temp; 818| | if constexpr (is_size_optimized(Opts)) { 819| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 820| | if (ec != std::errc{}) [[unlikely]] { 821| | ctx.error = error_code::parse_number_failure; 822| | return; 823| | } 824| | it = ptr; 825| | } 826| | else { 827| | auto [ptr, ec] = glz::from_chars(it, end, temp); 828| | if (ec != std::errc()) [[unlikely]] { 829| | ctx.error = error_code::parse_number_failure; 830| | return; 831| | } 832| | it = ptr; 833| | } 834| | value = temp; 835| | } 836| 3.52k| else { 837| | if constexpr (is_size_optimized(Opts)) { 838| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 839| | if (ec != std::errc{}) [[unlikely]] { 840| | ctx.error = error_code::parse_number_failure; 841| | return; 842| | } 843| | it = ptr; 844| | } 845| 3.52k| else { 846| 3.52k| auto [ptr, ec] = glz::from_chars(it, end, value); 847| 3.52k| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (847:26): [True: 572, False: 2.95k] ------------------ 848| 572| ctx.error = error_code::parse_number_failure; 849| 572| return; 850| 572| } 851| 2.95k| it = ptr; 852| 2.95k| } 853| 3.52k| } 854| 3.52k| } 855| 3.52k| } 856| | 857| | if constexpr (check_quoted_num(Opts)) { 858| | if constexpr (not Opts.null_terminated) { 859| | if (it == end) [[unlikely]] { 860| | ctx.error = error_code::unexpected_end; 861| | return; 862| | } 863| | } 864| | if (match<'"'>(ctx, it)) { 865| | return; 866| | } 867| | if constexpr (not Opts.null_terminated) { 868| | if (it == end) { 869| | ctx.error = error_code::end_reached; 870| | return; 871| | } 872| | } 873| | } 874| 3.52k| else { 875| 3.52k| if constexpr (not Opts.null_terminated) { 876| 3.52k| if (it == end) { ------------------ | Branch (876:20): [True: 1.89k, False: 1.63k] ------------------ 877| 1.89k| ctx.error = error_code::end_reached; 878| 1.89k| return; 879| 1.89k| } 880| 3.52k| } 881| 3.52k| } 882| 3.52k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm7EEEDav: 484| 1.23k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 1.23k| { 312| 1.23k| static constexpr auto Key = get(reflect::keys); 313| 1.23k| static constexpr auto KeyWithEndQuote = join_v>; 314| 1.23k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 1.23k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 1.22k, False: 9] | Branch (316:36): [True: 1.21k, False: 9] ------------------ 317| 1.21k| it += Length; 318| 1.21k| if constexpr (not Opts.null_terminated) { 319| 1.21k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 1.21k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 1.21k| } 324| | 325| 1.21k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 1.21k] ------------------ 326| 0| return; 327| 0| } 328| 1.21k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 22, False: 1.19k] ------------------ 329| 22| return; 330| 22| } 331| 1.19k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 1.19k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 1.19k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 1.19k| } 338| 18| else [[unlikely]] { 339| 18| decode_index_unknown_key(value, ctx, it, end); 340| 18| } 341| 1.23k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 1.19k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 1.19k| else { 273| 1.19k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 1.19k| else { 297| 1.19k| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 1.19k| it, end); 299| 1.19k| } 300| 1.19k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 1.19k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4065| 1.19k| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 1.19k| else { 4070| 1.19k| read_deduced(value, ctx, it, end); 4071| 1.19k| } 4072| 1.19k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4076| 1.19k| { 4077| 1.19k| constexpr auto Opts = ws_handled_off(); 4078| 1.19k| if constexpr (variant_is_auto_deducible()) { 4079| | if constexpr (not check_ws_handled(Options)) { 4080| | if (skip_ws(ctx, it, end)) { 4081| | return; 4082| | } 4083| | } 4084| | 4085| 1.19k| switch (*it) { 4086| 3| case '\0': ------------------ | Branch (4086:13): [True: 3, False: 1.19k] ------------------ 4087| 3| ctx.error = error_code::unexpected_end; 4088| 3| return; 4089| 159| case '{': { ------------------ | Branch (4089:13): [True: 159, False: 1.03k] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 159| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 159] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 159| ++it; 4099| 159| if constexpr (not Opts.null_terminated) { 4100| 159| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 0, False: 159] ------------------ 4101| 0| ctx.error = error_code::unexpected_end; 4102| 0| return; 4103| 0| } 4104| 159| } 4105| 159| using type_counts = variant_type_count; 4106| 159| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| | if constexpr (n_object_candidates < 1) { 4108| | ctx.error = error_code::no_matching_variant_type; 4109| | return; 4110| | } 4111| 159| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| 159| constexpr auto first_idx = variant_first_object_candidate_v; 4113| 159| using V = std::variant_alternative_t; 4114| 159| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4114:23): [True: 33, False: 126] ------------------ 4115| 159| parse::op()>(std::get(value), ctx, it, end); 4116| 159| return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 159| } 4801| 3| case '[': ------------------ | Branch (4801:13): [True: 3, False: 1.19k] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 3| process_variant_alternatives::template op(value, ctx, it, end); 4804| 3| break; 4805| 1.00k| case '"': { ------------------ | Branch (4805:13): [True: 1.00k, False: 194] ------------------ 4806| 1.00k| process_variant_alternatives::template op(value, ctx, it, end); 4807| 1.00k| break; 4808| 159| } 4809| 3| case 't': ------------------ | Branch (4809:13): [True: 3, False: 1.19k] ------------------ 4810| 6| case 'f': { ------------------ | Branch (4810:13): [True: 3, False: 1.19k] ------------------ 4811| 6| process_variant_alternatives::template op(value, ctx, it, end); 4812| 6| break; 4813| 3| } 4814| 3| case 'n': ------------------ | Branch (4814:13): [True: 3, False: 1.19k] ------------------ 4815| 3| if constexpr (variant_count_v == 0) { 4816| 3| ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| | else { 4819| | constexpr auto first_idx = variant_first_index_v; 4820| | using V = std::variant_alternative_t; 4821| | if (!std::holds_alternative(value)) value = V{}; 4822| | match<"null", Opts>(ctx, it, end); 4823| | } 4824| 3| break; 4825| 20| default: { ------------------ | Branch (4825:13): [True: 20, False: 1.17k] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 20| process_variant_alternatives::template op(value, ctx, it, end); 4828| 20| } 4829| 1.19k| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 1.19k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERN12jsonrpc_fuzz6amountETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 409| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 409| else { 60| 409| using V = std::remove_cvref_t; 61| 409| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 409| end); 63| 409| } 64| 409| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 409| { 3045| 409| static constexpr auto num_members = reflect::size; 3046| | 3047| 409| static constexpr auto Opts = opening_handled_off()>(); 3048| | if constexpr (!check_opening_handled(Options)) { 3049| | if constexpr (!check_ws_handled(Options)) { 3050| | if (skip_ws(ctx, it, end)) { 3051| | return; 3052| | } 3053| | } 3054| | if (match_invalid_end<'{', Opts>(ctx, it, end)) { 3055| | return; 3056| | } 3057| | if constexpr (not Opts.null_terminated) { 3058| | if (it == end) [[unlikely]] { 3059| | ctx.error = error_code::unexpected_end; 3060| | return; 3061| | } 3062| | } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| | if (enter_depth(ctx)) [[unlikely]] { 3066| | return; 3067| | } 3068| | } 3069| 409| const auto ws_start = it; 3070| 409| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 409] ------------------ 3071| 0| return; 3072| 0| } 3073| 409| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 409| else { 3148| 409| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 409| if constexpr ((glaze_object_t || reflectable) && 3150| 409| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 409| return bit_array{}; 3152| 409| } 3153| 409| else { 3154| 409| return nullptr; 3155| 409| } 3156| 409| }(); 3157| | 3158| 409| size_t read_count{}; // for partial_read 3159| | 3160| 409| bool first = true; 3161| 877| while (true) { ------------------ | Branch (3161:20): [True: 696, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 696| if (*it == '}') { ------------------ | Branch (3198:20): [True: 207, False: 489] ------------------ 3199| 207| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 207| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 207| } 3224| 207| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 207| if constexpr (not Opts.null_terminated) { 3226| 207| if (it == end) { ------------------ | Branch (3226:26): [True: 54, False: 153] ------------------ 3227| 54| ctx.error = error_code::end_reached; 3228| 54| return; 3229| 54| } 3230| 207| } 3231| 153| return; 3232| 207| } 3233| 489| else if (first) { ------------------ | Branch (3233:25): [True: 231, False: 258] ------------------ 3234| 231| first = false; 3235| 231| } 3236| 258| else { 3237| 258| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 21, False: 237] ------------------ 3238| 21| return; 3239| 21| } 3240| 237| if constexpr (not Opts.null_terminated) { 3241| 237| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 237] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 237| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| | (!Opts.comments)) { 3249| | if (ws_size && ws_size < size_t(end - it)) { 3250| | skip_matching_ws(ws_start, it, ws_size); 3251| | } 3252| | } 3253| | 3254| 237| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 237] ------------------ 3255| 0| return; 3256| 0| } 3257| 237| } 3258| | 3259| 468| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 468| else if constexpr (reflection_type) { 3324| 468| static_assert(bool(hash_info.type)); 3325| | 3326| 468| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 78, False: 390] ------------------ 3327| 78| ctx.error = error_code::expected_quote; 3328| 78| return; 3329| 78| } 3330| 390| ++it; 3331| 390| if constexpr (not Opts.null_terminated) { 3332| 390| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 390] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 390| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 390| else { 3386| 390| parse_and_invoke(value, ctx, it, end); 3387| 390| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 103, False: 287] ------------------ 3388| 103| return; 3389| 390| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 468| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 468] ------------------ 3499| 0| return; 3500| 0| } 3501| 468| } 3502| 409| } 3503| 409| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 409| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 409| else { 3154| 409| return nullptr; 3155| 409| } 3156| 409| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 376| 390| { 377| 390| constexpr auto N = reflect::size; 378| | 379| 390| if constexpr (N == 1) { 380| 390| decode_index(value, ctx, it, end, selected_index...); 381| | } 382| | else if constexpr (check_linear_search(Opts)) { 383| | // Linear search path 384| | auto key_start = it; 385| | const auto index = decode_linear(ctx, it, end); 386| | if (bool(ctx.error)) [[unlikely]] 387| | return; 388| | 389| | if (index >= N) [[unlikely]] { 390| | if constexpr (Opts.error_on_unknown_keys) { 391| | ctx.error = error_code::unknown_key; 392| | return; 393| | } 394| | else { 395| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 396| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 397| | return; 398| | } 399| | const sv key{key_start, size_t(it - key_start - 1)}; 400| | if constexpr (not Opts.null_terminated) { 401| | if (it == end) [[unlikely]] { 402| | ctx.error = error_code::unexpected_end; 403| | return; 404| | } 405| | } 406| | if (parse_ws_colon(ctx, it, end)) { 407| | return; 408| | } 409| | parse::handle_unknown(key, value, ctx, it, end); 410| | return; 411| | } 412| | } 413| | 414| | if constexpr (not Opts.null_terminated) { 415| | if (it == end) [[unlikely]] { 416| | ctx.error = error_code::unexpected_end; 417| | return; 418| | } 419| | } 420| | if (skip_ws(ctx, it, end)) { 421| | return; 422| | } 423| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 424| | return; 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | 430| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 431| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 432| | // instantiations; the whitespace before the value has already been skipped either way. 433| | [&](std::index_sequence) { 434| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 435| | : false) || 436| | ...)); 437| | }(std::make_index_sequence{}); 438| | } 439| | else { 440| | // Hash-based lookup 441| | constexpr auto& HashInfo = hash_info; 442| | constexpr auto type = HashInfo.type; 443| | static_assert(bool(type), "invalid hash algorithm"); 444| | 445| | const auto index = decode_hash::op(it, end); 446| | 447| | if (index >= N) [[unlikely]] { 448| | if constexpr (Opts.error_on_unknown_keys) { 449| | ctx.error = error_code::unknown_key; 450| | return; 451| | } 452| | else { 453| | auto start = it; 454| | skip_string_view(ctx, it, end); 455| | if (bool(ctx.error)) [[unlikely]] 456| | return; 457| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 458| | return; 459| | const sv key = {start, size_t(it - start)}; 460| | ++it; // skip the quote 461| | if constexpr (not Opts.null_terminated) { 462| | if (it == end) [[unlikely]] { 463| | ctx.error = error_code::unexpected_end; 464| | return; 465| | } 466| | } 467| | if (parse_ws_colon(ctx, it, end)) { 468| | return; 469| | } 470| | parse::handle_unknown(key, value, ctx, it, end); 471| | return; 472| | } 473| | } 474| | 475| | if constexpr (N == 2) { 476| | if (index == 0) { 477| | decode_index(value, ctx, it, end, selected_index...); 478| | } 479| | else { 480| | decode_index(value, ctx, it, end, selected_index...); 481| | } 482| | } 483| | else { 484| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 485| | } 486| | } 487| 390| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 390| { 312| 390| static constexpr auto Key = get(reflect::keys); 313| 390| static constexpr auto KeyWithEndQuote = join_v>; 314| 390| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 390| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 376, False: 14] | Branch (316:36): [True: 339, False: 37] ------------------ 317| 339| it += Length; 318| 339| if constexpr (not Opts.null_terminated) { 319| 339| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 339] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 339| } 324| | 325| 339| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 339] ------------------ 326| 0| return; 327| 0| } 328| 339| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 24, False: 315] ------------------ 329| 24| return; 330| 24| } 331| 315| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 315] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 315| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 315| } 338| 51| else [[unlikely]] { 339| 51| decode_index_unknown_key(value, ctx, it, end); 340| 51| } 341| 390| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 315| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 315| else { 273| 315| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 315| else { 297| 315| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 315| it, end); 299| 315| } 300| 315| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 315| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 51| { 178| 51| if constexpr (Opts.error_on_unknown_keys) { 179| 51| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 51| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3725| 20| { 3726| 20| constexpr auto category_count = variant_count_v; 3727| | 3728| 20| if constexpr (category_count == 0) { 3729| 20| ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| | else { 3732| | constexpr auto N = std::variant_size_v; 3733| | constexpr auto const_count = variant_filtered_count_v; 3734| | constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| | bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| | bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| | if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| | size_t non_const_idx = 0; 3793| | 3794| | for_each([&]() { 3795| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| | return; 3797| | } 3798| | using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| | }); 3850| | if (!found_match) { 3851| | if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| | } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| | } 3864| 20| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3725| 1.61k| { 3726| 1.61k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 1.61k| else { 3732| 1.61k| constexpr auto N = std::variant_size_v; 3733| 1.61k| constexpr auto const_count = variant_filtered_count_v; 3734| 1.61k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 1.61k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 1.61k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 1.61k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 1.61k| size_t non_const_idx = 0; 3793| | 3794| 1.61k| for_each([&]() { 3795| 1.61k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 1.61k| return; 3797| 1.61k| } 3798| 1.61k| using V = std::variant_alternative_t; 3799| 1.61k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 1.61k| auto copy_it{it}; 3801| 1.61k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 1.61k| if (!std::holds_alternative(value)) { 3803| 1.61k| value = V{}; 3804| 1.61k| } 3805| 1.61k| parse::op()>(std::get(value), ctx, it, end); 3806| 1.61k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 1.61k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 1.61k| } 3809| 1.61k| if (!bool(ctx.error)) { 3810| 1.61k| found_match = true; 3811| 1.61k| } 3812| 1.61k| else if constexpr (not Options.null_terminated) { 3813| 1.61k| constexpr bool is_complete_type = 3814| 1.61k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 1.61k| if constexpr (is_complete_type) { 3817| 1.61k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 1.61k| found_match = true; 3819| 1.61k| ctx.error = error_code::none; 3820| 1.61k| } 3821| 1.61k| else { 3822| 1.61k| it = copy_it; 3823| 1.61k| rewind_depth(ctx, copy_depth); 3824| 1.61k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 1.61k| not variant_alternative_exhausted(ctx)) { 3826| 1.61k| ctx.error = error_code::none; 3827| 1.61k| } 3828| 1.61k| } 3829| 1.61k| } 3830| 1.61k| else { 3831| 1.61k| it = copy_it; 3832| 1.61k| rewind_depth(ctx, copy_depth); 3833| 1.61k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 1.61k| not variant_alternative_exhausted(ctx)) { 3835| 1.61k| ctx.error = error_code::none; 3836| 1.61k| } 3837| 1.61k| } 3838| 1.61k| } 3839| 1.61k| else { 3840| 1.61k| it = copy_it; 3841| 1.61k| rewind_depth(ctx, copy_depth); 3842| 1.61k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 1.61k| not variant_alternative_exhausted(ctx)) { 3844| 1.61k| ctx.error = error_code::none; 3845| 1.61k| } 3846| 1.61k| } 3847| 1.61k| ++non_const_idx; 3848| 1.61k| } 3849| 1.61k| }); 3850| 1.61k| if (!found_match) { ------------------ | Branch (3850:20): [True: 316, False: 1.30k] ------------------ 3851| 316| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 316| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 1.61k| } 3864| 1.61k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 1.61k| for_each([&]() { 3795| 1.61k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 1.61k] | Branch (3795:38): [True: 0, False: 1.61k] | Branch (3795:51): [True: 0, False: 1.61k] ------------------ 3796| 0| return; 3797| 0| } 3798| 1.61k| using V = std::variant_alternative_t; 3799| 1.61k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 1.61k| auto copy_it{it}; 3801| 1.61k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 1.61k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 5, False: 1.61k] ------------------ 3803| 5| value = V{}; 3804| 5| } 3805| 1.61k| parse::op()>(std::get(value), ctx, it, end); 3806| 1.61k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 481, False: 1.13k] | Branch (3806:45): [True: 0, False: 481] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 1.61k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 1.13k, False: 481] ------------------ 3810| 1.13k| found_match = true; 3811| 1.13k| } 3812| 481| else if constexpr (not Options.null_terminated) { 3813| 481| constexpr bool is_complete_type = 3814| 481| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [Folded, False: 0] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [True: 0, Folded] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| 481| if constexpr (is_complete_type) { 3817| 481| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3817:32): [True: 165, False: 316] | Branch (3817:72): [True: 165, False: 0] | Branch (3817:88): [True: 165, False: 0] ------------------ 3818| 165| found_match = true; 3819| 165| ctx.error = error_code::none; 3820| 165| } 3821| 316| else { 3822| 316| it = copy_it; 3823| 316| rewind_depth(ctx, copy_depth); 3824| 316| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3824:35): [True: 0, False: 316] | Branch (3824:74): [True: 0, False: 0] ------------------ 3825| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3825:35): [True: 0, False: 0] ------------------ 3826| 0| ctx.error = error_code::none; 3827| 0| } 3828| 316| } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 1.61k| ++non_const_idx; 3848| 1.61k| } 3849| 1.61k| }); _ZN3glz29variant_alternative_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 3714| 3.18M| { 3715| 3.18M| return ctx.error == error_code::exceeded_max_recursive_depth; 3716| 3.18M| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 751k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 751k| else { 60| 751k| using V = std::remove_cvref_t; 61| 751k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 751k| end); 63| 751k| } 64| 751k| } _ZN3glz12rewind_depthITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextEEEvRT0_j: 3697| 48.6k| { 3698| 48.6k| if (ctx.error == error_code::exceeded_max_recursive_depth) [[unlikely]] { ------------------ | Branch (3698:11): [True: 0, False: 48.6k] ------------------ 3699| 0| return; 3700| 0| } 3701| | if constexpr (Opts.null_terminated) { 3702| | ctx.depth = depth; 3703| | } 3704| 48.6k| else { 3705| 48.6k| if (ctx.error != error_code::end_reached && ctx.error != error_code::unexpected_end) { ------------------ | Branch (3705:14): [True: 47.5k, False: 1.11k] | Branch (3705:54): [True: 47.4k, False: 2] ------------------ 3706| 47.4k| ctx.depth = depth; 3707| 47.4k| } 3708| 48.6k| } 3709| 48.6k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 1.61k| for_each([&]() { 3795| 1.61k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 1.30k, False: 316] | Branch (3795:38): [True: 0, False: 316] | Branch (3795:51): [True: 0, False: 316] ------------------ 3796| 1.30k| return; 3797| 1.30k| } 3798| 316| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 316| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3725| 12| { 3726| 12| constexpr auto category_count = variant_count_v; 3727| | 3728| 12| if constexpr (category_count == 0) { 3729| 12| ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| | else { 3732| | constexpr auto N = std::variant_size_v; 3733| | constexpr auto const_count = variant_filtered_count_v; 3734| | constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| | bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| | bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| | if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| | size_t non_const_idx = 0; 3793| | 3794| | for_each([&]() { 3795| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| | return; 3797| | } 3798| | using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| | }); 3850| | if (!found_match) { 3851| | if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| | } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| | } 3864| 12| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3725| 234| { 3726| 234| constexpr auto category_count = variant_count_v; 3727| | 3728| 234| if constexpr (category_count == 0) { 3729| 234| ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| | else { 3732| | constexpr auto N = std::variant_size_v; 3733| | constexpr auto const_count = variant_filtered_count_v; 3734| | constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| | bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| | bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| | if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| | size_t non_const_idx = 0; 3793| | 3794| | for_each([&]() { 3795| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| | return; 3797| | } 3798| | using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| | }); 3850| | if (!found_match) { 3851| | if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| | } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| | } 3864| 234| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm8EEEDav: 484| 413| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 413| { 312| 413| static constexpr auto Key = get(reflect::keys); 313| 413| static constexpr auto KeyWithEndQuote = join_v>; 314| 413| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 413| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 410, False: 3] | Branch (316:36): [True: 263, False: 147] ------------------ 317| 263| it += Length; 318| 263| if constexpr (not Opts.null_terminated) { 319| 263| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 263] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 263| } 324| | 325| 263| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 263] ------------------ 326| 0| return; 327| 0| } 328| 263| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 22, False: 241] ------------------ 329| 22| return; 330| 22| } 331| 241| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 241] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 241| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 241| } 338| 150| else [[unlikely]] { 339| 150| decode_index_unknown_key(value, ctx, it, end); 340| 150| } 341| 413| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 241| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 241| else { 273| 241| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 241| else { 297| 241| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 241| it, end); 299| 241| } 300| 241| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 241| } _ZN3glz4fromILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 2179| 241| { 2180| | if constexpr (!check_ws_handled(Opts)) { 2181| | if (skip_ws(ctx, it, end)) { 2182| | return; 2183| | } 2184| | } 2185| 241| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2185:14): [True: 20, False: 221] ------------------ 2186| 20| return; 2187| 20| } 2188| 221| skip_string_view(ctx, it, end); 2189| 221| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2189:14): [True: 0, False: 221] ------------------ 2190| 0| return; 2191| 221| if (match<'"'>(ctx, it)) { ------------------ | Branch (2191:14): [True: 0, False: 221] ------------------ 2192| 0| return; 2193| 0| } 2194| 221| if constexpr (not Opts.null_terminated) { 2195| 221| if (it == end) { ------------------ | Branch (2195:17): [True: 0, False: 221] ------------------ 2196| 0| ctx.error = error_code::end_reached; 2197| 0| return; 2198| 0| } 2199| 221| } 2200| 221| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm9EEEDav: 484| 287| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 287| { 312| 287| static constexpr auto Key = get(reflect::keys); 313| 287| static constexpr auto KeyWithEndQuote = join_v>; 314| 287| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 287| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 284, False: 3] | Branch (316:36): [True: 279, False: 5] ------------------ 317| 279| it += Length; 318| 279| if constexpr (not Opts.null_terminated) { 319| 279| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 279] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 279| } 324| | 325| 279| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 279] ------------------ 326| 0| return; 327| 0| } 328| 279| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 38, False: 241] ------------------ 329| 38| return; 330| 38| } 331| 241| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 241] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 241| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 241| } 338| 8| else [[unlikely]] { 339| 8| decode_index_unknown_key(value, ctx, it, end); 340| 8| } 341| 287| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 241| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 241| else { 273| 241| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 241| else { 297| 241| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 241| it, end); 299| 241| } 300| 241| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 241| } _ZN3glz4fromILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEESC_TkNS_10is_contextERNS_7contextERPKcSJ_EEvRT0_OT1_OT2_T3_: 2179| 241| { 2180| | if constexpr (!check_ws_handled(Opts)) { 2181| | if (skip_ws(ctx, it, end)) { 2182| | return; 2183| | } 2184| | } 2185| 241| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2185:14): [True: 20, False: 221] ------------------ 2186| 20| return; 2187| 20| } 2188| 221| skip_string_view(ctx, it, end); 2189| 221| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2189:14): [True: 0, False: 221] ------------------ 2190| 0| return; 2191| 221| if (match<'"'>(ctx, it)) { ------------------ | Branch (2191:14): [True: 0, False: 221] ------------------ 2192| 0| return; 2193| 0| } 2194| 221| if constexpr (not Opts.null_terminated) { 2195| 221| if (it == end) { ------------------ | Branch (2195:17): [True: 0, False: 221] ------------------ 2196| 0| ctx.error = error_code::end_reached; 2197| 0| return; 2198| 0| } 2199| 221| } 2200| 221| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm10EEEDav: 484| 100| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 100| { 312| 100| static constexpr auto Key = get(reflect::keys); 313| 100| static constexpr auto KeyWithEndQuote = join_v>; 314| 100| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 100| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 97, False: 3] | Branch (316:36): [True: 74, False: 23] ------------------ 317| 74| it += Length; 318| 74| if constexpr (not Opts.null_terminated) { 319| 74| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 74] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 74| } 324| | 325| 74| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 74] ------------------ 326| 0| return; 327| 0| } 328| 74| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 22, False: 52] ------------------ 329| 22| return; 330| 22| } 331| 52| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 52] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 52| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 52| } 338| 26| else [[unlikely]] { 339| 26| decode_index_unknown_key(value, ctx, it, end); 340| 26| } 341| 100| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 52| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 52| else { 273| 52| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 52| else { 297| 52| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 52| it, end); 299| 52| } 300| 52| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 52| } _ZN3glz4fromILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES8_TkNS_10is_contextERNS_7contextERPKcSF_EEvRT0_OT1_OT2_T3_: 2179| 52| { 2180| | if constexpr (!check_ws_handled(Opts)) { 2181| | if (skip_ws(ctx, it, end)) { 2182| | return; 2183| | } 2184| | } 2185| 52| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2185:14): [True: 24, False: 28] ------------------ 2186| 24| return; 2187| 24| } 2188| 28| skip_string_view(ctx, it, end); 2189| 28| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2189:14): [True: 0, False: 28] ------------------ 2190| 0| return; 2191| 28| if (match<'"'>(ctx, it)) { ------------------ | Branch (2191:14): [True: 0, False: 28] ------------------ 2192| 0| return; 2193| 0| } 2194| 28| if constexpr (not Opts.null_terminated) { 2195| 28| if (it == end) { ------------------ | Branch (2195:17): [True: 0, False: 28] ------------------ 2196| 0| ctx.error = error_code::end_reached; 2197| 0| return; 2198| 0| } 2199| 28| } 2200| 28| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm11EEEDav: 484| 80| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 80| { 312| 80| static constexpr auto Key = get(reflect::keys); 313| 80| static constexpr auto KeyWithEndQuote = join_v>; 314| 80| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 80| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 77, False: 3] | Branch (316:36): [True: 74, False: 3] ------------------ 317| 74| it += Length; 318| 74| if constexpr (not Opts.null_terminated) { 319| 74| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 74] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 74| } 324| | 325| 74| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 74] ------------------ 326| 0| return; 327| 0| } 328| 74| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 25, False: 49] ------------------ 329| 25| return; 330| 25| } 331| 49| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 49] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 49| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 49| } 338| 6| else [[unlikely]] { 339| 6| decode_index_unknown_key(value, ctx, it, end); 340| 6| } 341| 80| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 49| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 49| else { 273| 49| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 49| else { 297| 49| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 49| it, end); 299| 49| } 300| 49| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 49| } _ZN3glz4fromILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES9_TkNS_10is_contextERNS_7contextERPKcSG_EEvRT0_OT1_OT2_T3_: 2179| 49| { 2180| | if constexpr (!check_ws_handled(Opts)) { 2181| | if (skip_ws(ctx, it, end)) { 2182| | return; 2183| | } 2184| | } 2185| 49| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2185:14): [True: 22, False: 27] ------------------ 2186| 22| return; 2187| 22| } 2188| 27| skip_string_view(ctx, it, end); 2189| 27| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2189:14): [True: 0, False: 27] ------------------ 2190| 0| return; 2191| 27| if (match<'"'>(ctx, it)) { ------------------ | Branch (2191:14): [True: 0, False: 27] ------------------ 2192| 0| return; 2193| 0| } 2194| 27| if constexpr (not Opts.null_terminated) { 2195| 27| if (it == end) { ------------------ | Branch (2195:17): [True: 0, False: 27] ------------------ 2196| 0| ctx.error = error_code::end_reached; 2197| 0| return; 2198| 0| } 2199| 27| } 2200| 27| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm12EEEDav: 484| 163| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 163| { 312| 163| static constexpr auto Key = get(reflect::keys); 313| 163| static constexpr auto KeyWithEndQuote = join_v>; 314| 163| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 163| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 160, False: 3] | Branch (316:36): [True: 157, False: 3] ------------------ 317| 157| it += Length; 318| 157| if constexpr (not Opts.null_terminated) { 319| 157| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 157] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 157| } 324| | 325| 157| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 157] ------------------ 326| 0| return; 327| 0| } 328| 157| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 37, False: 120] ------------------ 329| 37| return; 330| 37| } 331| 120| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 120] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 120| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 120| } 338| 6| else [[unlikely]] { 339| 6| decode_index_unknown_key(value, ctx, it, end); 340| 6| } 341| 163| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 120| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 120| else { 273| 120| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| | else if constexpr (glaze_object_t) { 293| | from>::template op(get_member(value, get(reflect::values)), 294| | ctx, it, end); 295| | } 296| 120| else { 297| 120| from>::template op(get_member(value, get(to_tie(value))), ctx, 298| 120| it, end); 299| 120| } 300| 120| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 120| } _ZN3glz4fromILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 2179| 120| { 2180| | if constexpr (!check_ws_handled(Opts)) { 2181| | if (skip_ws(ctx, it, end)) { 2182| | return; 2183| | } 2184| | } 2185| 120| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2185:14): [True: 24, False: 96] ------------------ 2186| 24| return; 2187| 24| } 2188| 96| skip_string_view(ctx, it, end); 2189| 96| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2189:14): [True: 0, False: 96] ------------------ 2190| 0| return; 2191| 96| if (match<'"'>(ctx, it)) { ------------------ | Branch (2191:14): [True: 0, False: 96] ------------------ 2192| 0| return; 2193| 0| } 2194| 96| if constexpr (not Opts.null_terminated) { 2195| 96| if (it == end) { ------------------ | Branch (2195:17): [True: 0, False: 96] ------------------ 2196| 0| ctx.error = error_code::end_reached; 2197| 0| return; 2198| 0| } 2199| 96| } 2200| 96| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 1.62k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.62k| else { 60| 1.62k| using V = std::remove_cvref_t; 61| 1.62k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.62k| end); 63| 1.62k| } 64| 1.62k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 1.62k| { 3045| 1.62k| static constexpr auto num_members = reflect::size; 3046| | 3047| 1.62k| static constexpr auto Opts = opening_handled_off()>(); 3048| 1.62k| if constexpr (!check_opening_handled(Options)) { 3049| 1.62k| if constexpr (!check_ws_handled(Options)) { 3050| 1.62k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3050:20): [True: 0, False: 1.62k] ------------------ 3051| 0| return; 3052| 0| } 3053| 1.62k| } 3054| 1.62k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 89, False: 1.53k] ------------------ 3055| 89| return; 3056| 89| } 3057| 1.53k| if constexpr (not Opts.null_terminated) { 3058| 1.53k| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 1.53k] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 1.53k| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 1.53k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 1.53k] ------------------ 3066| 0| return; 3067| 0| } 3068| 1.53k| } 3069| 1.53k| const auto ws_start = it; 3070| 1.62k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 1.62k] ------------------ 3071| 0| return; 3072| 0| } 3073| 1.62k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 1.62k| else { 3148| 1.62k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 1.62k| if constexpr ((glaze_object_t || reflectable) && 3150| 1.62k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 1.62k| return bit_array{}; 3152| 1.62k| } 3153| 1.62k| else { 3154| 1.62k| return nullptr; 3155| 1.62k| } 3156| 1.62k| }(); 3157| | 3158| 1.62k| size_t read_count{}; // for partial_read 3159| | 3160| 1.62k| bool first = true; 3161| 13.0k| while (true) { ------------------ | Branch (3161:20): [True: 11.7k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 11.7k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 237, False: 11.5k] ------------------ 3199| 237| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 237| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 237| } 3224| 237| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 237| if constexpr (not Opts.null_terminated) { 3226| 237| if (it == end) { ------------------ | Branch (3226:26): [True: 237, False: 0] ------------------ 3227| 237| ctx.error = error_code::end_reached; 3228| 237| return; 3229| 237| } 3230| 237| } 3231| 0| return; 3232| 237| } 3233| 11.5k| else if (first) { ------------------ | Branch (3233:25): [True: 1.49k, False: 10.0k] ------------------ 3234| 1.49k| first = false; 3235| 1.49k| } 3236| 10.0k| else { 3237| 10.0k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 122, False: 9.92k] ------------------ 3238| 122| return; 3239| 122| } 3240| 9.92k| if constexpr (not Opts.null_terminated) { 3241| 9.92k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 9.92k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 9.92k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 9.92k| (!Opts.comments)) { 3249| 9.92k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 8.52k, False: 1.39k] | Branch (3249:37): [True: 8.29k, False: 226] ------------------ 3250| 8.29k| skip_matching_ws(ws_start, it, ws_size); 3251| 8.29k| } 3252| 9.92k| } 3253| | 3254| 9.92k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 9.92k] ------------------ 3255| 0| return; 3256| 0| } 3257| 9.92k| } 3258| | 3259| 11.4k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [True: 0, Folded] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 11.4k| else if constexpr (reflection_type) { 3324| 11.4k| static_assert(bool(hash_info.type)); 3325| | 3326| 11.4k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 802, False: 10.6k] ------------------ 3327| 802| ctx.error = error_code::expected_quote; 3328| 802| return; 3329| 802| } 3330| 10.6k| ++it; 3331| 10.6k| if constexpr (not Opts.null_terminated) { 3332| 10.6k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 0, False: 10.6k] ------------------ 3333| 0| ctx.error = error_code::unexpected_end; 3334| 0| return; 3335| 0| } 3336| 10.6k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 10.6k| else { 3386| 10.6k| parse_and_invoke(value, ctx, it, end); 3387| 10.6k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 375, False: 10.2k] ------------------ 3388| 375| return; 3389| 10.6k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 11.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 11.4k] ------------------ 3499| 0| return; 3500| 0| } 3501| 11.4k| } 3502| 1.62k| } 3503| 1.62k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 1.53k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 1.53k| else { 3154| 1.53k| return nullptr; 3155| 1.53k| } 3156| 1.53k| }(); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS4_9allocatorIiEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 2.03k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 2.03k| else { 60| 2.03k| using V = std::remove_cvref_t; 61| 2.03k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 2.03k| end); 63| 2.03k| } 64| 2.03k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2308| 2.03k| { 2309| 2.03k| constexpr auto Opts = ws_handled_off(); 2310| 2.03k| if constexpr (!check_ws_handled(Options)) { 2311| 2.03k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2311:17): [True: 0, False: 2.03k] ------------------ 2312| 0| return; 2313| 0| } 2314| 2.03k| } 2315| | 2316| 2.03k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2316:14): [True: 57, False: 1.98k] ------------------ 2317| 57| return; 2318| 57| } 2319| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2320| | // released at each syntactic close below 2321| 1.98k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2321:14): [True: 0, False: 1.98k] ------------------ 2322| 0| return; 2323| 0| } 2324| | 2325| 1.98k| const auto ws_start = it; 2326| 1.98k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2326:14): [True: 0, False: 1.98k] ------------------ 2327| 0| return; 2328| 0| } 2329| | 2330| 1.98k| if (*it == ']') { ------------------ | Branch (2330:14): [True: 22, False: 1.95k] ------------------ 2331| 22| --ctx.depth; 2332| 22| ++it; 2333| 22| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2334| 22| value.clear(); 2335| | 2336| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2337| | value.shrink_to_fit(); 2338| | } 2339| 22| } 2340| 22| return; 2341| 22| } 2342| | 2343| 1.95k| const size_t ws_size = size_t(it - ws_start); 2344| | 2345| 1.95k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2345:49): [True: 1.95k, Folded] | Branch (2345:65): [Folded, False: 0] | Branch (2345:90): [Folded, False: 0] ------------------ 2346| 1.95k| if constexpr (not should_append) { 2347| 1.95k| const auto n = value.size(); 2348| | 2349| 1.95k| auto value_it = value.begin(); 2350| | 2351| 1.95k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2351:32): [True: 0, False: 1.95k] ------------------ 2352| 0| parse::op()>(*value_it++, ctx, it, end); 2353| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2353:20): [True: 0, False: 0] ------------------ 2354| 0| return; 2355| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2355:20): [True: 0, False: 0] ------------------ 2356| 0| return; 2357| 0| } 2358| 0| if (*it == ',') { ------------------ | Branch (2358:20): [True: 0, False: 0] ------------------ 2359| 0| ++it; 2360| | 2361| 0| if constexpr (!Opts.minified && !Opts.comments) { 2362| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2362:26): [True: 0, False: 0] | Branch (2362:37): [True: 0, False: 0] ------------------ 2363| 0| skip_matching_ws(ws_start, it, ws_size); 2364| 0| } 2365| 0| } 2366| | 2367| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:23): [True: 0, False: 0] ------------------ 2368| 0| return; 2369| 0| } 2370| 0| } 2371| 0| else if (*it == ']') { ------------------ | Branch (2371:25): [True: 0, False: 0] ------------------ 2372| 0| --ctx.depth; 2373| 0| ++it; 2374| 0| if constexpr (erasable) { 2375| 0| value.erase(value_it, 2376| 0| value.end()); // use erase rather than resize for non-default constructible elements 2377| | 2378| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2379| | value.shrink_to_fit(); 2380| | } 2381| 0| } 2382| 0| return; 2383| 0| } 2384| 0| else [[unlikely]] { 2385| 0| ctx.error = error_code::expected_bracket; 2386| 0| return; 2387| 0| } 2388| 0| } 2389| 1.95k| } 2390| | 2391| | if constexpr (Opts.partial_read) { 2392| | // partial_read stops early on a success path, so give the level back like the 2393| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2394| | --ctx.depth; 2395| | return; 2396| | } 2397| 1.95k| else { 2398| | // growing 2399| 1.95k| if constexpr (emplace_backable || has_try_emplace_back) { 2400| 574k| while (it < end) { ------------------ | Branch (2400:23): [True: 574k, False: 0] ------------------ 2401| | // Streaming refill point: at start of each iteration, ensure buffer has data 2402| | if constexpr (has_streaming_state) { 2403| | if (ctx.stream.enabled()) { 2404| | const size_t consumed = static_cast(it - ctx.stream.data()); 2405| | const size_t remaining = ctx.stream.size() - consumed; 2406| | // Refill when less than half of buffer remains to ensure space for next element 2407| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2408| | const char* new_it; 2409| | const char* new_end; 2410| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2411| | it = new_it; 2412| | end = new_end; 2413| | if (it >= end && ctx.stream.at_eof()) { 2414| | break; // No more data, exit loop normally 2415| | } 2416| | } 2417| | } 2418| | } 2419| | 2420| | if constexpr (has_try_emplace_back) { 2421| | if (value.try_emplace_back()) 2422| | parse::op()>(value.back(), ctx, it, end); 2423| | else 2424| | ctx.error = error_code::exceeded_static_array_size; 2425| | } 2426| 574k| else { 2427| 574k| parse::op()>(value.emplace_back(), ctx, it, end); 2428| 574k| } 2429| | 2430| 574k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2430:23): [True: 1.12k, False: 573k] ------------------ 2431| 1.12k| return; 2432| | 2433| | // Streaming refill point: after parsing each element, refill if buffer is low 2434| | if constexpr (has_streaming_state) { 2435| | if (ctx.stream.enabled()) { 2436| | const size_t consumed = static_cast(it - ctx.stream.data()); 2437| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2438| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2439| | const char* new_it; 2440| | const char* new_end; 2441| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2442| | it = new_it; 2443| | end = new_end; 2444| | if (it >= end && ctx.stream.at_eof()) { 2445| | ctx.error = error_code::unexpected_end; 2446| | return; 2447| | } 2448| | } 2449| | } 2450| | } 2451| | 2452| 573k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2452:23): [True: 0, False: 573k] ------------------ 2453| 0| return; 2454| 0| } 2455| 573k| if (*it == ',') [[likely]] { ------------------ | Branch (2455:23): [True: 572k, False: 838] ------------------ 2456| 572k| ++it; 2457| | 2458| 572k| if constexpr (!Opts.minified && !Opts.comments) { 2459| 572k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2459:29): [True: 521k, False: 51.2k] | Branch (2459:40): [True: 520k, False: 418] ------------------ 2460| 520k| skip_matching_ws(ws_start, it, ws_size); 2461| 520k| } 2462| 572k| } 2463| | 2464| 572k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2464:26): [True: 0, False: 572k] ------------------ 2465| 0| return; 2466| 0| } 2467| 572k| } 2468| 838| else if (*it == ']') { ------------------ | Branch (2468:28): [True: 419, False: 419] ------------------ 2469| 419| --ctx.depth; 2470| 419| ++it; 2471| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2472| | value.shrink_to_fit(); 2473| | } 2474| 419| return; 2475| 419| } 2476| 419| else [[unlikely]] { 2477| 419| ctx.error = error_code::expected_bracket; 2478| 419| return; 2479| 419| } 2480| 573k| } 2481| | 2482| | // A valid array always returns from inside the loop upon reaching ']'. 2483| | // For a null-terminated buffer the loop can only exit here by falling 2484| | // through when `it` reaches the terminator without a closing bracket, 2485| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2486| | // Non-null-terminated buffers surface this through skip_ws/depth 2487| | // tracking (or the streaming refill break), so this guard is limited 2488| | // to the null-terminated case. 2489| | if constexpr (Opts.null_terminated) { 2490| | ctx.error = error_code::unexpected_end; 2491| | } 2492| | } 2493| | else { 2494| | ctx.error = error_code::exceeded_static_array_size; 2495| | } 2496| 1.95k| } 2497| 1.95k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEETkNS_10is_contextERNS_7contextERPKcSN_EEvOT0_OT1_OT2_T3_: 49| 1.91k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.91k| else { 60| 1.91k| using V = std::remove_cvref_t; 61| 1.91k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.91k| end); 63| 1.91k| } 64| 1.91k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 3044| 1.91k| { 3045| 1.91k| static constexpr auto num_members = reflect::size; 3046| | 3047| 1.91k| static constexpr auto Opts = opening_handled_off()>(); 3048| 1.91k| if constexpr (!check_opening_handled(Options)) { 3049| 1.91k| if constexpr (!check_ws_handled(Options)) { 3050| 1.91k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3050:20): [True: 0, False: 1.91k] ------------------ 3051| 0| return; 3052| 0| } 3053| 1.91k| } 3054| 1.91k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 46, False: 1.87k] ------------------ 3055| 46| return; 3056| 46| } 3057| 1.87k| if constexpr (not Opts.null_terminated) { 3058| 1.87k| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 1.87k] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 1.87k| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 1.87k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 1.87k] ------------------ 3066| 0| return; 3067| 0| } 3068| 1.87k| } 3069| 1.87k| const auto ws_start = it; 3070| 1.91k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 1.91k] ------------------ 3071| 0| return; 3072| 0| } 3073| 1.91k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 1.91k| else { 3148| 1.91k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 1.91k| if constexpr ((glaze_object_t || reflectable) && 3150| 1.91k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 1.91k| return bit_array{}; 3152| 1.91k| } 3153| 1.91k| else { 3154| 1.91k| return nullptr; 3155| 1.91k| } 3156| 1.91k| }(); 3157| | 3158| 1.91k| size_t read_count{}; // for partial_read 3159| | 3160| 1.91k| bool first = true; 3161| 25.7k| while (true) { ------------------ | Branch (3161:20): [True: 24.4k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 24.4k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 339, False: 24.1k] ------------------ 3199| 339| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| | if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| | } 3224| 339| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 339| if constexpr (not Opts.null_terminated) { 3226| 339| if (it == end) { ------------------ | Branch (3226:26): [True: 339, False: 0] ------------------ 3227| 339| ctx.error = error_code::end_reached; 3228| 339| return; 3229| 339| } 3230| 339| } 3231| 0| return; 3232| 339| } 3233| 24.1k| else if (first) { ------------------ | Branch (3233:25): [True: 1.84k, False: 22.2k] ------------------ 3234| 1.84k| first = false; 3235| 1.84k| } 3236| 22.2k| else { 3237| 22.2k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 282, False: 22.0k] ------------------ 3238| 282| return; 3239| 282| } 3240| 22.0k| if constexpr (not Opts.null_terminated) { 3241| 22.0k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 22.0k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 22.0k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| | (!Opts.comments)) { 3249| | if (ws_size && ws_size < size_t(end - it)) { 3250| | skip_matching_ws(ws_start, it, ws_size); 3251| | } 3252| | } 3253| | 3254| 22.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 22.0k] ------------------ 3255| 0| return; 3256| 0| } 3257| 22.0k| } 3258| | 3259| 23.8k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [Folded, False: 0] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| | else if constexpr (reflection_type) { 3324| | static_assert(bool(hash_info.type)); 3325| | 3326| | if (*it != '"') [[unlikely]] { 3327| | ctx.error = error_code::expected_quote; 3328| | return; 3329| | } 3330| | ++it; 3331| | if constexpr (not Opts.null_terminated) { 3332| | if (it == end) [[unlikely]] { 3333| | ctx.error = error_code::unexpected_end; 3334| | return; 3335| | } 3336| | } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| | else { 3386| | parse_and_invoke(value, ctx, it, end); 3387| | if (bool(ctx.error)) [[unlikely]] 3388| | return; 3389| | } 3390| | } 3391| 23.8k| else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| 23.8k| auto reading = [&](auto&& key) { 3395| 23.8k| if constexpr (Opts.partial_read) { 3396| 23.8k| if (auto element = value.find(key); element != value.end()) { 3397| 23.8k| ++read_count; 3398| 23.8k| parse::op()>(element->second, ctx, it, end); 3399| 23.8k| } 3400| 23.8k| else { 3401| 23.8k| skip_value::op(ctx, it, end); 3402| 23.8k| } 3403| 23.8k| } 3404| 23.8k| else { 3405| 23.8k| parse::op()>(value[key], ctx, it, end); 3406| 23.8k| } 3407| 23.8k| }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| 23.8k| using Key = typename T::key_type; 3411| 23.8k| if constexpr (std::is_same_v) { 3412| 23.8k| ctx.scratch.clear(); 3413| 23.8k| parse::op(ctx.scratch, ctx, it, end); 3414| 23.8k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3414:26): [True: 288, False: 23.5k] ------------------ 3415| 288| return; 3416| | 3417| 23.5k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3417:26): [True: 264, False: 23.3k] ------------------ 3418| 264| return; 3419| 264| } 3420| | 3421| 23.3k| reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| 23.3k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 697, False: 22.6k] ------------------ 3428| 697| return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| 23.8k| } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 23.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 23.8k] ------------------ 3499| 0| return; 3500| 0| } 3501| 23.8k| } 3502| 1.91k| } 3503| 1.91k| } _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 1.87k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 1.87k| else { 3154| 1.87k| return nullptr; 3155| 1.87k| } 3156| 1.87k| }(); _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRS8_EEDaSZ_: 3394| 23.3k| auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| 23.3k| else { 3405| 23.3k| parse::op()>(value[key], ctx, it, end); 3406| 23.3k| } 3407| 23.3k| }; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 49| 2.08k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 2.08k| else { 60| 2.08k| using V = std::remove_cvref_t; 61| 2.08k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 2.08k| end); 63| 2.08k| } 64| 2.08k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 5088| 2.08k| { 5089| 2.08k| constexpr auto Opts = ws_handled_off(); 5090| 2.08k| if constexpr (!check_ws_handled(Options)) { 5091| 2.08k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (5091:17): [True: 0, False: 2.08k] ------------------ 5092| 0| return; 5093| 0| } 5094| 2.08k| } 5095| | 5096| 2.08k| if (*it == 'n') { ------------------ | Branch (5096:14): [True: 0, False: 2.08k] ------------------ 5097| 0| ++it; 5098| 0| if constexpr (not Opts.null_terminated) { 5099| 0| if (it == end) [[unlikely]] { ------------------ | Branch (5099:20): [True: 0, False: 0] ------------------ 5100| 0| ctx.error = error_code::unexpected_end; 5101| 0| return; 5102| 0| } 5103| 0| } 5104| 0| match<"ull", Opts>(ctx, it, end); 5105| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (5105:17): [True: 0, False: 0] ------------------ 5106| 0| return; 5107| 0| if constexpr (requires { value.reset(); }) { 5108| 0| value.reset(); 5109| 0| } 5110| 0| } 5111| 2.08k| else { 5112| 2.08k| if constexpr (nullable_value_t) { 5113| 2.08k| if (not value.has_value()) { ------------------ | Branch (5113:20): [True: 2.08k, False: 0] ------------------ 5114| | if constexpr (constructible) { 5115| | value = meta_construct_v(); 5116| | } 5117| 2.08k| else if constexpr (requires { value.emplace(); }) { 5118| 2.08k| value.emplace(); 5119| | } 5120| | else { 5121| | static_assert(false_v, 5122| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 5123| | "create a custom glz::from specialization"); 5124| | } 5125| 2.08k| } 5126| 2.08k| parse::op(value.value(), ctx, it, end); 5127| | } 5128| | else { 5129| | if (!value) { 5130| | if (!nullable_emplace(value, ctx)) { 5131| | return; 5132| | } 5133| | } 5134| | parse::op(*value, ctx, it, end); 5135| | } 5136| 2.08k| } 5137| 2.08k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 49| 1.10k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.10k| else { 60| 1.10k| using V = std::remove_cvref_t; 61| 1.10k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.10k| end); 63| 1.10k| } 64| 1.10k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4065| 1.10k| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 1.10k| else { 4070| 1.10k| read_deduced(value, ctx, it, end); 4071| 1.10k| } 4072| 1.10k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4076| 1.10k| { 4077| 1.10k| constexpr auto Opts = ws_handled_off(); 4078| 1.10k| if constexpr (variant_is_auto_deducible()) { 4079| 1.10k| if constexpr (not check_ws_handled(Options)) { 4080| 1.10k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (4080:20): [True: 0, False: 1.10k] ------------------ 4081| 0| return; 4082| 0| } 4083| 1.10k| } 4084| | 4085| 1.10k| switch (*it) { 4086| 0| case '\0': ------------------ | Branch (4086:13): [True: 0, False: 1.10k] ------------------ 4087| 0| ctx.error = error_code::unexpected_end; 4088| 0| return; 4089| 250| case '{': { ------------------ | Branch (4089:13): [True: 250, False: 856] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 250| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 250] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 250| ++it; 4099| 250| if constexpr (not Opts.null_terminated) { 4100| 250| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 0, False: 250] ------------------ 4101| 0| ctx.error = error_code::unexpected_end; 4102| 0| return; 4103| 0| } 4104| 250| } 4105| 250| using type_counts = variant_type_count; 4106| 250| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| | if constexpr (n_object_candidates < 1) { 4108| | ctx.error = error_code::no_matching_variant_type; 4109| | return; 4110| | } 4111| 250| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| 250| constexpr auto first_idx = variant_first_object_candidate_v; 4113| 250| using V = std::variant_alternative_t; 4114| 250| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4114:23): [True: 250, False: 0] ------------------ 4115| 250| parse::op()>(std::get(value), ctx, it, end); 4116| 250| return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 250| } 4801| 17| case '[': ------------------ | Branch (4801:13): [True: 17, False: 1.08k] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 17| process_variant_alternatives::template op(value, ctx, it, end); 4804| 17| break; 4805| 619| case '"': { ------------------ | Branch (4805:13): [True: 619, False: 487] ------------------ 4806| 619| process_variant_alternatives::template op(value, ctx, it, end); 4807| 619| break; 4808| 250| } 4809| 3| case 't': ------------------ | Branch (4809:13): [True: 3, False: 1.10k] ------------------ 4810| 6| case 'f': { ------------------ | Branch (4810:13): [True: 3, False: 1.10k] ------------------ 4811| 6| process_variant_alternatives::template op(value, ctx, it, end); 4812| 6| break; 4813| 3| } 4814| 0| case 'n': ------------------ | Branch (4814:13): [True: 0, False: 1.10k] ------------------ 4815| 0| if constexpr (variant_count_v == 0) { 4816| 0| ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| | else { 4819| | constexpr auto first_idx = variant_first_index_v; 4820| | using V = std::variant_alternative_t; 4821| | if (!std::holds_alternative(value)) value = V{}; 4822| | match<"null", Opts>(ctx, it, end); 4823| | } 4824| 0| break; 4825| 214| default: { ------------------ | Branch (4825:13): [True: 214, False: 892] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 214| process_variant_alternatives::template op(value, ctx, it, end); 4828| 214| } 4829| 1.10k| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 1.10k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS4_9allocatorIdEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 3.92k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 3.92k| else { 60| 3.92k| using V = std::remove_cvref_t; 61| 3.92k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.92k| end); 63| 3.92k| } 64| 3.92k| } _ZN3glz4fromILj10ENSt3__16vectorIdNS1_9allocatorIdEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2308| 3.92k| { 2309| 3.92k| constexpr auto Opts = ws_handled_off(); 2310| 3.92k| if constexpr (!check_ws_handled(Options)) { 2311| 3.92k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2311:17): [True: 0, False: 3.92k] ------------------ 2312| 0| return; 2313| 0| } 2314| 3.92k| } 2315| | 2316| 3.92k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2316:14): [True: 112, False: 3.81k] ------------------ 2317| 112| return; 2318| 112| } 2319| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2320| | // released at each syntactic close below 2321| 3.81k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2321:14): [True: 0, False: 3.81k] ------------------ 2322| 0| return; 2323| 0| } 2324| | 2325| 3.81k| const auto ws_start = it; 2326| 3.81k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2326:14): [True: 0, False: 3.81k] ------------------ 2327| 0| return; 2328| 0| } 2329| | 2330| 3.81k| if (*it == ']') { ------------------ | Branch (2330:14): [True: 22, False: 3.78k] ------------------ 2331| 22| --ctx.depth; 2332| 22| ++it; 2333| 22| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2334| 22| value.clear(); 2335| | 2336| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2337| | value.shrink_to_fit(); 2338| | } 2339| 22| } 2340| 22| return; 2341| 22| } 2342| | 2343| 3.78k| const size_t ws_size = size_t(it - ws_start); 2344| | 2345| 3.78k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2345:49): [True: 3.78k, Folded] | Branch (2345:65): [Folded, False: 0] | Branch (2345:90): [Folded, False: 0] ------------------ 2346| 3.78k| if constexpr (not should_append) { 2347| 3.78k| const auto n = value.size(); 2348| | 2349| 3.78k| auto value_it = value.begin(); 2350| | 2351| 3.78k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2351:32): [True: 0, False: 3.78k] ------------------ 2352| 0| parse::op()>(*value_it++, ctx, it, end); 2353| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2353:20): [True: 0, False: 0] ------------------ 2354| 0| return; 2355| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2355:20): [True: 0, False: 0] ------------------ 2356| 0| return; 2357| 0| } 2358| 0| if (*it == ',') { ------------------ | Branch (2358:20): [True: 0, False: 0] ------------------ 2359| 0| ++it; 2360| | 2361| 0| if constexpr (!Opts.minified && !Opts.comments) { 2362| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2362:26): [True: 0, False: 0] | Branch (2362:37): [True: 0, False: 0] ------------------ 2363| 0| skip_matching_ws(ws_start, it, ws_size); 2364| 0| } 2365| 0| } 2366| | 2367| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:23): [True: 0, False: 0] ------------------ 2368| 0| return; 2369| 0| } 2370| 0| } 2371| 0| else if (*it == ']') { ------------------ | Branch (2371:25): [True: 0, False: 0] ------------------ 2372| 0| --ctx.depth; 2373| 0| ++it; 2374| 0| if constexpr (erasable) { 2375| 0| value.erase(value_it, 2376| 0| value.end()); // use erase rather than resize for non-default constructible elements 2377| | 2378| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2379| | value.shrink_to_fit(); 2380| | } 2381| 0| } 2382| 0| return; 2383| 0| } 2384| 0| else [[unlikely]] { 2385| 0| ctx.error = error_code::expected_bracket; 2386| 0| return; 2387| 0| } 2388| 0| } 2389| 3.78k| } 2390| | 2391| | if constexpr (Opts.partial_read) { 2392| | // partial_read stops early on a success path, so give the level back like the 2393| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2394| | --ctx.depth; 2395| | return; 2396| | } 2397| 3.78k| else { 2398| | // growing 2399| 3.78k| if constexpr (emplace_backable || has_try_emplace_back) { 2400| 614k| while (it < end) { ------------------ | Branch (2400:23): [True: 614k, False: 0] ------------------ 2401| | // Streaming refill point: at start of each iteration, ensure buffer has data 2402| | if constexpr (has_streaming_state) { 2403| | if (ctx.stream.enabled()) { 2404| | const size_t consumed = static_cast(it - ctx.stream.data()); 2405| | const size_t remaining = ctx.stream.size() - consumed; 2406| | // Refill when less than half of buffer remains to ensure space for next element 2407| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2408| | const char* new_it; 2409| | const char* new_end; 2410| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2411| | it = new_it; 2412| | end = new_end; 2413| | if (it >= end && ctx.stream.at_eof()) { 2414| | break; // No more data, exit loop normally 2415| | } 2416| | } 2417| | } 2418| | } 2419| | 2420| | if constexpr (has_try_emplace_back) { 2421| | if (value.try_emplace_back()) 2422| | parse::op()>(value.back(), ctx, it, end); 2423| | else 2424| | ctx.error = error_code::exceeded_static_array_size; 2425| | } 2426| 614k| else { 2427| 614k| parse::op()>(value.emplace_back(), ctx, it, end); 2428| 614k| } 2429| | 2430| 614k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2430:23): [True: 1.00k, False: 613k] ------------------ 2431| 1.00k| return; 2432| | 2433| | // Streaming refill point: after parsing each element, refill if buffer is low 2434| | if constexpr (has_streaming_state) { 2435| | if (ctx.stream.enabled()) { 2436| | const size_t consumed = static_cast(it - ctx.stream.data()); 2437| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2438| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2439| | const char* new_it; 2440| | const char* new_end; 2441| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2442| | it = new_it; 2443| | end = new_end; 2444| | if (it >= end && ctx.stream.at_eof()) { 2445| | ctx.error = error_code::unexpected_end; 2446| | return; 2447| | } 2448| | } 2449| | } 2450| | } 2451| | 2452| 613k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2452:23): [True: 0, False: 613k] ------------------ 2453| 0| return; 2454| 0| } 2455| 613k| if (*it == ',') [[likely]] { ------------------ | Branch (2455:23): [True: 610k, False: 2.78k] ------------------ 2456| 610k| ++it; 2457| | 2458| 610k| if constexpr (!Opts.minified && !Opts.comments) { 2459| 610k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2459:29): [True: 11.5k, False: 599k] | Branch (2459:40): [True: 11.2k, False: 270] ------------------ 2460| 11.2k| skip_matching_ws(ws_start, it, ws_size); 2461| 11.2k| } 2462| 610k| } 2463| | 2464| 610k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2464:26): [True: 0, False: 610k] ------------------ 2465| 0| return; 2466| 0| } 2467| 610k| } 2468| 2.78k| else if (*it == ']') { ------------------ | Branch (2468:28): [True: 1.85k, False: 933] ------------------ 2469| 1.85k| --ctx.depth; 2470| 1.85k| ++it; 2471| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2472| | value.shrink_to_fit(); 2473| | } 2474| 1.85k| return; 2475| 1.85k| } 2476| 933| else [[unlikely]] { 2477| 933| ctx.error = error_code::expected_bracket; 2478| 933| return; 2479| 933| } 2480| 613k| } 2481| | 2482| | // A valid array always returns from inside the loop upon reaching ']'. 2483| | // For a null-terminated buffer the loop can only exit here by falling 2484| | // through when `it` reaches the terminator without a closing bracket, 2485| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2486| | // Non-null-terminated buffers surface this through skip_ws/depth 2487| | // tracking (or the streaming refill break), so this guard is limited 2488| | // to the null-terminated case. 2489| | if constexpr (Opts.null_terminated) { 2490| | ctx.error = error_code::unexpected_end; 2491| | } 2492| | } 2493| | else { 2494| | ctx.error = error_code::exceeded_static_array_size; 2495| | } 2496| 3.78k| } 2497| 3.78k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 881k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 881k| else { 60| 881k| using V = std::remove_cvref_t; 61| 881k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 881k| end); 63| 881k| } 64| 881k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorINS_14basic_raw_jsonINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEENS4_9allocatorISB_EEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 49| 25.3k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 25.3k| else { 60| 25.3k| using V = std::remove_cvref_t; 61| 25.3k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 25.3k| end); 63| 25.3k| } 64| 25.3k| } _ZN3glz4fromILj10ENSt3__16vectorINS_14basic_raw_jsonINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_9allocatorIS8_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 2308| 25.3k| { 2309| 25.3k| constexpr auto Opts = ws_handled_off(); 2310| 25.3k| if constexpr (!check_ws_handled(Options)) { 2311| 25.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2311:17): [True: 0, False: 25.3k] ------------------ 2312| 0| return; 2313| 0| } 2314| 25.3k| } 2315| | 2316| 25.3k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2316:14): [True: 29, False: 25.3k] ------------------ 2317| 29| return; 2318| 29| } 2319| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2320| | // released at each syntactic close below 2321| 25.3k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2321:14): [True: 0, False: 25.3k] ------------------ 2322| 0| return; 2323| 0| } 2324| | 2325| 25.3k| const auto ws_start = it; 2326| 25.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2326:14): [True: 13, False: 25.3k] ------------------ 2327| 13| return; 2328| 13| } 2329| | 2330| 25.3k| if (*it == ']') { ------------------ | Branch (2330:14): [True: 13, False: 25.3k] ------------------ 2331| 13| --ctx.depth; 2332| 13| ++it; 2333| 13| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2334| 13| value.clear(); 2335| | 2336| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2337| | value.shrink_to_fit(); 2338| | } 2339| 13| } 2340| 13| return; 2341| 13| } 2342| | 2343| 25.3k| const size_t ws_size = size_t(it - ws_start); 2344| | 2345| 25.3k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2345:49): [True: 25.3k, Folded] | Branch (2345:65): [Folded, False: 0] | Branch (2345:90): [Folded, False: 0] ------------------ 2346| 25.3k| if constexpr (not should_append) { 2347| 25.3k| const auto n = value.size(); 2348| | 2349| 25.3k| auto value_it = value.begin(); 2350| | 2351| 25.3k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2351:32): [True: 0, False: 25.3k] ------------------ 2352| 0| parse::op()>(*value_it++, ctx, it, end); 2353| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2353:20): [True: 0, False: 0] ------------------ 2354| 0| return; 2355| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2355:20): [True: 0, False: 0] ------------------ 2356| 0| return; 2357| 0| } 2358| 0| if (*it == ',') { ------------------ | Branch (2358:20): [True: 0, False: 0] ------------------ 2359| 0| ++it; 2360| | 2361| 0| if constexpr (!Opts.minified && !Opts.comments) { 2362| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2362:26): [True: 0, False: 0] | Branch (2362:37): [True: 0, False: 0] ------------------ 2363| 0| skip_matching_ws(ws_start, it, ws_size); 2364| 0| } 2365| 0| } 2366| | 2367| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:23): [True: 0, False: 0] ------------------ 2368| 0| return; 2369| 0| } 2370| 0| } 2371| 0| else if (*it == ']') { ------------------ | Branch (2371:25): [True: 0, False: 0] ------------------ 2372| 0| --ctx.depth; 2373| 0| ++it; 2374| 0| if constexpr (erasable) { 2375| 0| value.erase(value_it, 2376| 0| value.end()); // use erase rather than resize for non-default constructible elements 2377| | 2378| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2379| | value.shrink_to_fit(); 2380| | } 2381| 0| } 2382| 0| return; 2383| 0| } 2384| 0| else [[unlikely]] { 2385| 0| ctx.error = error_code::expected_bracket; 2386| 0| return; 2387| 0| } 2388| 0| } 2389| 25.3k| } 2390| | 2391| | if constexpr (Opts.partial_read) { 2392| | // partial_read stops early on a success path, so give the level back like the 2393| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2394| | --ctx.depth; 2395| | return; 2396| | } 2397| 25.3k| else { 2398| | // growing 2399| 25.3k| if constexpr (emplace_backable || has_try_emplace_back) { 2400| 5.18M| while (it < end) { ------------------ | Branch (2400:23): [True: 5.18M, False: 0] ------------------ 2401| | // Streaming refill point: at start of each iteration, ensure buffer has data 2402| | if constexpr (has_streaming_state) { 2403| | if (ctx.stream.enabled()) { 2404| | const size_t consumed = static_cast(it - ctx.stream.data()); 2405| | const size_t remaining = ctx.stream.size() - consumed; 2406| | // Refill when less than half of buffer remains to ensure space for next element 2407| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2408| | const char* new_it; 2409| | const char* new_end; 2410| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2411| | it = new_it; 2412| | end = new_end; 2413| | if (it >= end && ctx.stream.at_eof()) { 2414| | break; // No more data, exit loop normally 2415| | } 2416| | } 2417| | } 2418| | } 2419| | 2420| | if constexpr (has_try_emplace_back) { 2421| | if (value.try_emplace_back()) 2422| | parse::op()>(value.back(), ctx, it, end); 2423| | else 2424| | ctx.error = error_code::exceeded_static_array_size; 2425| | } 2426| 5.18M| else { 2427| 5.18M| parse::op()>(value.emplace_back(), ctx, it, end); 2428| 5.18M| } 2429| | 2430| 5.18M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2430:23): [True: 3.32k, False: 5.18M] ------------------ 2431| 3.32k| return; 2432| | 2433| | // Streaming refill point: after parsing each element, refill if buffer is low 2434| | if constexpr (has_streaming_state) { 2435| | if (ctx.stream.enabled()) { 2436| | const size_t consumed = static_cast(it - ctx.stream.data()); 2437| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2438| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2439| | const char* new_it; 2440| | const char* new_end; 2441| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2442| | it = new_it; 2443| | end = new_end; 2444| | if (it >= end && ctx.stream.at_eof()) { 2445| | ctx.error = error_code::unexpected_end; 2446| | return; 2447| | } 2448| | } 2449| | } 2450| | } 2451| | 2452| 5.18M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2452:23): [True: 378, False: 5.18M] ------------------ 2453| 378| return; 2454| 378| } 2455| 5.18M| if (*it == ',') [[likely]] { ------------------ | Branch (2455:23): [True: 5.15M, False: 21.5k] ------------------ 2456| 5.15M| ++it; 2457| | 2458| 5.15M| if constexpr (!Opts.minified && !Opts.comments) { 2459| 5.15M| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2459:29): [True: 296k, False: 4.86M] | Branch (2459:40): [True: 296k, False: 557] ------------------ 2460| 296k| skip_matching_ws(ws_start, it, ws_size); 2461| 296k| } 2462| 5.15M| } 2463| | 2464| 5.15M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2464:26): [True: 47, False: 5.15M] ------------------ 2465| 47| return; 2466| 47| } 2467| 5.15M| } 2468| 21.5k| else if (*it == ']') { ------------------ | Branch (2468:28): [True: 18.0k, False: 3.48k] ------------------ 2469| 18.0k| --ctx.depth; 2470| 18.0k| ++it; 2471| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2472| | value.shrink_to_fit(); 2473| | } 2474| 18.0k| return; 2475| 18.0k| } 2476| 3.48k| else [[unlikely]] { 2477| 3.48k| ctx.error = error_code::expected_bracket; 2478| 3.48k| return; 2479| 3.48k| } 2480| 5.18M| } 2481| | 2482| | // A valid array always returns from inside the loop upon reaching ']'. 2483| | // For a null-terminated buffer the loop can only exit here by falling 2484| | // through when `it` reaches the terminator without a closing bracket, 2485| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2486| | // Non-null-terminated buffers surface this through skip_ws/depth 2487| | // tracking (or the streaming refill break), so this guard is limited 2488| | // to the null-terminated case. 2489| | if constexpr (Opts.null_terminated) { 2490| | ctx.error = error_code::unexpected_end; 2491| | } 2492| | } 2493| | else { 2494| | ctx.error = error_code::exceeded_static_array_size; 2495| | } 2496| 25.3k| } 2497| 25.3k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 5.18M| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 5.18M| else { 60| 5.18M| using V = std::remove_cvref_t; 61| 5.18M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 5.18M| end); 63| 5.18M| } 64| 5.18M| } _ZN3glz4fromILj10ENS_14basic_raw_jsonINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 2208| 5.22M| { 2209| 5.22M| auto it_start = it; 2210| 5.22M| if (*it == 'n') { ------------------ | Branch (2210:14): [True: 1.20k, False: 5.22M] ------------------ 2211| 1.20k| match<"null", Opts>(ctx, it, end); 2212| 1.20k| } 2213| 5.22M| else if (is_digit(uint8_t(*it))) { ------------------ | Branch (2213:19): [True: 55.8k, False: 5.16M] ------------------ 2214| 55.8k| skip_number(ctx, it, end); 2215| 55.8k| } 2216| 5.16M| else { 2217| 5.16M| skip_value::op(ctx, it, end); 2218| 5.16M| } 2219| 5.22M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2219:14): [True: 6.64k, False: 5.21M] ------------------ 2220| 6.64k| return; 2221| 5.21M| if constexpr (string_view_t) { 2222| 5.21M| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 5.21M| static_assert(!::glz::has_streaming_state, \ | | 243| 5.21M| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 5.21M| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 5.21M| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 5.21M| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 5.21M| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 5.21M| "container), or read from a buffer that holds the whole document.") ------------------ 2223| 5.21M| } 2224| 5.21M| value.str = {it_start, static_cast(it - it_start)}; 2225| 5.21M| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_3rpc18request_envelope_tETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 379k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 379k| else { 60| 379k| using V = std::remove_cvref_t; 61| 379k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 379k| end); 63| 379k| } 64| 379k| } _ZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3044| 379k| { 3045| 379k| static constexpr auto num_members = reflect::size; 3046| | 3047| 379k| static constexpr auto Opts = opening_handled_off()>(); 3048| 379k| if constexpr (!check_opening_handled(Options)) { 3049| 379k| if constexpr (!check_ws_handled(Options)) { 3050| 379k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3050:20): [True: 13, False: 379k] ------------------ 3051| 13| return; 3052| 13| } 3053| 379k| } 3054| 379k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3054:17): [True: 236k, False: 143k] ------------------ 3055| 236k| return; 3056| 236k| } 3057| 143k| if constexpr (not Opts.null_terminated) { 3058| 143k| if (it == end) [[unlikely]] { ------------------ | Branch (3058:20): [True: 0, False: 143k] ------------------ 3059| 0| ctx.error = error_code::unexpected_end; 3060| 0| return; 3061| 0| } 3062| 143k| } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| 143k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3065:17): [True: 0, False: 143k] ------------------ 3066| 0| return; 3067| 0| } 3068| 143k| } 3069| 143k| const auto ws_start = it; 3070| 379k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 18, False: 379k] ------------------ 3071| 18| return; 3072| 18| } 3073| 379k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 379k| else { 3148| 379k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 379k| if constexpr ((glaze_object_t || reflectable) && 3150| 379k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 379k| return bit_array{}; 3152| 379k| } 3153| 379k| else { 3154| 379k| return nullptr; 3155| 379k| } 3156| 379k| }(); 3157| | 3158| 379k| size_t read_count{}; // for partial_read 3159| | 3160| 379k| bool first = true; 3161| 666k| while (true) { ------------------ | Branch (3161:20): [True: 357k, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 357k| if (*it == '}') { ------------------ | Branch (3198:20): [True: 62.1k, False: 295k] ------------------ 3199| 62.1k| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| 62.1k| if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| 62.1k| } 3224| 62.1k| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 62.1k| if constexpr (not Opts.null_terminated) { 3226| 62.1k| if (it == end) { ------------------ | Branch (3226:26): [True: 57.6k, False: 4.51k] ------------------ 3227| 57.6k| ctx.error = error_code::end_reached; 3228| 57.6k| return; 3229| 57.6k| } 3230| 62.1k| } 3231| 4.51k| return; 3232| 62.1k| } 3233| 295k| else if (first) { ------------------ | Branch (3233:25): [True: 140k, False: 155k] ------------------ 3234| 140k| first = false; 3235| 140k| } 3236| 155k| else { 3237| 155k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 7.94k, False: 147k] ------------------ 3238| 7.94k| return; 3239| 7.94k| } 3240| 147k| if constexpr (not Opts.null_terminated) { 3241| 147k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 147k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 147k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| 147k| (!Opts.comments)) { 3249| 147k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3249:26): [True: 10.4k, False: 136k] | Branch (3249:37): [True: 8.94k, False: 1.54k] ------------------ 3250| 8.94k| skip_matching_ws(ws_start, it, ws_size); 3251| 8.94k| } 3252| 147k| } 3253| | 3254| 147k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 5, False: 147k] ------------------ 3255| 5| return; 3256| 5| } 3257| 147k| } 3258| | 3259| 287k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [True: 287k, Folded] | Branch (3259:70): [Folded, False: 0] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| 287k| else if constexpr (reflection_type) { 3324| 287k| static_assert(bool(hash_info.type)); 3325| | 3326| 287k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3326:23): [True: 18.8k, False: 268k] ------------------ 3327| 18.8k| ctx.error = error_code::expected_quote; 3328| 18.8k| return; 3329| 18.8k| } 3330| 268k| ++it; 3331| 268k| if constexpr (not Opts.null_terminated) { 3332| 268k| if (it == end) [[unlikely]] { ------------------ | Branch (3332:26): [True: 3, False: 268k] ------------------ 3333| 3| ctx.error = error_code::unexpected_end; 3334| 3| return; 3335| 3| } 3336| 268k| } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| 268k| else { 3386| 268k| parse_and_invoke(value, ctx, it, end); 3387| 268k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3387:26): [True: 54.4k, False: 214k] ------------------ 3388| 54.4k| return; 3389| 268k| } 3390| | } 3391| | else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| | auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| | else { 3405| | parse::op()>(value[key], ctx, it, end); 3406| | } 3407| | }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| | using Key = typename T::key_type; 3411| | if constexpr (std::is_same_v) { 3412| | ctx.scratch.clear(); 3413| | parse::op(ctx.scratch, ctx, it, end); 3414| | if (bool(ctx.error)) [[unlikely]] 3415| | return; 3416| | 3417| | if (parse_ws_colon(ctx, it, end)) { 3418| | return; 3419| | } 3420| | 3421| | reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| | } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 287k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 259, False: 287k] ------------------ 3499| 259| return; 3500| 259| } 3501| 287k| } 3502| 379k| } 3503| 379k| } _ZZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 143k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 143k| else { 3154| 143k| return nullptr; 3155| 143k| } 3156| 143k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 376| 268k| { 377| 268k| constexpr auto N = reflect::size; 378| | 379| | if constexpr (N == 1) { 380| | decode_index(value, ctx, it, end, selected_index...); 381| | } 382| | else if constexpr (check_linear_search(Opts)) { 383| | // Linear search path 384| | auto key_start = it; 385| | const auto index = decode_linear(ctx, it, end); 386| | if (bool(ctx.error)) [[unlikely]] 387| | return; 388| | 389| | if (index >= N) [[unlikely]] { 390| | if constexpr (Opts.error_on_unknown_keys) { 391| | ctx.error = error_code::unknown_key; 392| | return; 393| | } 394| | else { 395| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 396| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 397| | return; 398| | } 399| | const sv key{key_start, size_t(it - key_start - 1)}; 400| | if constexpr (not Opts.null_terminated) { 401| | if (it == end) [[unlikely]] { 402| | ctx.error = error_code::unexpected_end; 403| | return; 404| | } 405| | } 406| | if (parse_ws_colon(ctx, it, end)) { 407| | return; 408| | } 409| | parse::handle_unknown(key, value, ctx, it, end); 410| | return; 411| | } 412| | } 413| | 414| | if constexpr (not Opts.null_terminated) { 415| | if (it == end) [[unlikely]] { 416| | ctx.error = error_code::unexpected_end; 417| | return; 418| | } 419| | } 420| | if (skip_ws(ctx, it, end)) { 421| | return; 422| | } 423| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 424| | return; 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | 430| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 431| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 432| | // instantiations; the whitespace before the value has already been skipped either way. 433| | [&](std::index_sequence) { 434| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 435| | : false) || 436| | ...)); 437| | }(std::make_index_sequence{}); 438| | } 439| 268k| else { 440| | // Hash-based lookup 441| 268k| constexpr auto& HashInfo = hash_info; 442| 268k| constexpr auto type = HashInfo.type; 443| 268k| static_assert(bool(type), "invalid hash algorithm"); 444| | 445| 268k| const auto index = decode_hash::op(it, end); 446| | 447| 268k| if (index >= N) [[unlikely]] { ------------------ | Branch (447:14): [True: 19.1k, False: 249k] ------------------ 448| 19.1k| if constexpr (Opts.error_on_unknown_keys) { 449| 19.1k| ctx.error = error_code::unknown_key; 450| 19.1k| return; 451| | } 452| | else { 453| | auto start = it; 454| | skip_string_view(ctx, it, end); 455| | if (bool(ctx.error)) [[unlikely]] 456| | return; 457| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 458| | return; 459| | const sv key = {start, size_t(it - start)}; 460| | ++it; // skip the quote 461| | if constexpr (not Opts.null_terminated) { 462| | if (it == end) [[unlikely]] { 463| | ctx.error = error_code::unexpected_end; 464| | return; 465| | } 466| | } 467| | if (parse_ws_colon(ctx, it, end)) { 468| | return; 469| | } 470| | parse::handle_unknown(key, value, ctx, it, end); 471| | return; 472| | } 473| 19.1k| } 474| | 475| | if constexpr (N == 2) { 476| | if (index == 0) { 477| | decode_index(value, ctx, it, end, selected_index...); 478| | } 479| | else { 480| | decode_index(value, ctx, it, end, selected_index...); 481| | } 482| | } 483| 268k| else { 484| 268k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 485| 268k| } 486| 268k| } 487| 268k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav: 484| 68.4k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 68.4k| { 312| 68.4k| static constexpr auto Key = get(reflect::keys); 313| 68.4k| static constexpr auto KeyWithEndQuote = join_v>; 314| 68.4k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 68.4k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 68.1k, False: 354] | Branch (316:36): [True: 66.5k, False: 1.64k] ------------------ 317| 66.5k| it += Length; 318| 66.5k| if constexpr (not Opts.null_terminated) { 319| 66.5k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 66.5k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 66.5k| } 324| | 325| 66.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 2, False: 66.5k] ------------------ 326| 2| return; 327| 2| } 328| 66.5k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 2.02k, False: 64.4k] ------------------ 329| 2.02k| return; 330| 2.02k| } 331| 64.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 2, False: 64.4k] ------------------ 332| 2| return; 333| 2| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 64.4k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 64.4k| } 338| 1.99k| else [[unlikely]] { 339| 1.99k| decode_index_unknown_key(value, ctx, it, end); 340| 1.99k| } 341| 68.4k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 64.4k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 64.4k| else { 273| 64.4k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| 64.4k| else if constexpr (glaze_object_t) { 293| 64.4k| from>::template op(get_member(value, get(reflect::values)), 294| 64.4k| ctx, it, end); 295| | } 296| | else { 297| | from>::template op(get_member(value, get(to_tie(value))), ctx, 298| | it, end); 299| | } 300| 64.4k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 64.4k| } _ZN3glz4fromILj10ENSt3__18optionalINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 5088| 119k| { 5089| 119k| constexpr auto Opts = ws_handled_off(); 5090| | if constexpr (!check_ws_handled(Options)) { 5091| | if (skip_ws(ctx, it, end)) { 5092| | return; 5093| | } 5094| | } 5095| | 5096| 119k| if (*it == 'n') { ------------------ | Branch (5096:14): [True: 1.15k, False: 118k] ------------------ 5097| 1.15k| ++it; 5098| 1.15k| if constexpr (not Opts.null_terminated) { 5099| 1.15k| if (it == end) [[unlikely]] { ------------------ | Branch (5099:20): [True: 1, False: 1.15k] ------------------ 5100| 1| ctx.error = error_code::unexpected_end; 5101| 1| return; 5102| 1| } 5103| 1.15k| } 5104| 1.15k| match<"ull", Opts>(ctx, it, end); 5105| 1.15k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (5105:17): [True: 609, False: 548] ------------------ 5106| 609| return; 5107| 548| if constexpr (requires { value.reset(); }) { 5108| 548| value.reset(); 5109| 548| } 5110| 548| } 5111| 118k| else { 5112| 118k| if constexpr (nullable_value_t) { 5113| 118k| if (not value.has_value()) { ------------------ | Branch (5113:20): [True: 117k, False: 1.11k] ------------------ 5114| | if constexpr (constructible) { 5115| | value = meta_construct_v(); 5116| | } 5117| 117k| else if constexpr (requires { value.emplace(); }) { 5118| 117k| value.emplace(); 5119| | } 5120| | else { 5121| | static_assert(false_v, 5122| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 5123| | "create a custom glz::from specialization"); 5124| | } 5125| 117k| } 5126| 118k| parse::op(value.value(), ctx, it, end); 5127| | } 5128| | else { 5129| | if (!value) { 5130| | if (!nullable_emplace(value, ctx)) { 5131| | return; 5132| | } 5133| | } 5134| | parse::op(*value, ctx, it, end); 5135| | } 5136| 118k| } 5137| 119k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 118k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 118k| else { 60| 118k| using V = std::remove_cvref_t; 61| 118k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 118k| end); 63| 118k| } 64| 118k| } _ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_: 1864| 118k| { 1865| 118k| if constexpr (!check_opening_handled(Opts)) { 1866| 118k| if constexpr (!check_ws_handled(Opts)) { 1867| 118k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (1867:20): [True: 0, False: 118k] ------------------ 1868| 0| return; 1869| 0| } 1870| 118k| } 1871| | 1872| 118k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1872:17): [True: 1.50k, False: 117k] ------------------ 1873| 1.50k| return; 1874| 1.50k| } 1875| 118k| } 1876| | 1877| 117k| auto start = it; 1878| 118k| skip_string_view(ctx, it, end); 1879| 118k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1879:14): [True: 2, False: 118k] ------------------ 1880| 2| return; 1881| | 1882| 118k| if (validate_utf8_span(ctx, start, it)) [[unlikely]] { ------------------ | Branch (1882:14): [True: 34, False: 118k] ------------------ 1883| 34| return; 1884| 34| } 1885| | 1886| 118k| if constexpr (string_view_t) { 1887| 118k| if constexpr (!Transient) { 1888| 118k| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 118k| static_assert(!::glz::has_streaming_state, \ | | 243| 118k| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 118k| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 118k| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 118k| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 118k| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 118k| "container), or read from a buffer that holds the whole document.") ------------------ 1889| 118k| } 1890| 118k| using value_type = typename std::decay_t::value_type; 1891| | if constexpr (std::same_as) { 1892| | value = {reinterpret_cast(start), size_t(it - start)}; 1893| | } 1894| 118k| else { 1895| 118k| value = {start, size_t(it - start)}; 1896| 118k| } 1897| | } 1898| | else if constexpr (char_array_t) { 1899| | const size_t n = it - start; 1900| | if ((n + 1) > sizeof(value)) { 1901| | ctx.error = error_code::unexpected_end; 1902| | return; 1903| | } 1904| | std::memcpy(value, start, n); 1905| | value[n] = '\0'; 1906| | } 1907| | else if constexpr (array_char_t) { 1908| | const size_t n = it - start; 1909| | if ((n + 1) > value.size()) { 1910| | ctx.error = error_code::unexpected_end; 1911| | return; 1912| | } 1913| | std::memcpy(value.data(), start, n); 1914| | value[n] = '\0'; 1915| | } 1916| | else if constexpr (static_string_t) { 1917| | const size_t n = it - start; 1918| | if (n > value.capacity()) { 1919| | ctx.error = error_code::unexpected_end; 1920| | return; 1921| | } 1922| | value.assign(start, n); 1923| | } 1924| 118k| ++it; // skip closing quote 1925| 118k| if constexpr (not Opts.null_terminated) { 1926| 118k| if (it == end) { ------------------ | Branch (1926:17): [True: 5, False: 118k] ------------------ 1927| 5| ctx.error = error_code::end_reached; 1928| 5| return; 1929| 5| } 1930| 118k| } 1931| 118k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 7.13k| { 178| 7.13k| if constexpr (Opts.error_on_unknown_keys) { 179| 7.13k| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 7.13k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav: 484| 56.6k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 56.6k| { 312| 56.6k| static constexpr auto Key = get(reflect::keys); 313| 56.6k| static constexpr auto KeyWithEndQuote = join_v>; 314| 56.6k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 56.6k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 55.9k, False: 640] | Branch (316:36): [True: 55.4k, False: 530] ------------------ 317| 55.4k| it += Length; 318| 55.4k| if constexpr (not Opts.null_terminated) { 319| 55.4k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 55.4k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 55.4k| } 324| | 325| 55.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 55.4k] ------------------ 326| 0| return; 327| 0| } 328| 55.4k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 0, False: 55.4k] ------------------ 329| 0| return; 330| 0| } 331| 55.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 55.4k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 55.4k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 55.4k| } 338| 1.17k| else [[unlikely]] { 339| 1.17k| decode_index_unknown_key(value, ctx, it, end); 340| 1.17k| } 341| 56.6k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 55.4k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 55.4k| else { 273| 55.4k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| 55.4k| else if constexpr (glaze_object_t) { 293| 55.4k| from>::template op(get_member(value, get(reflect::values)), 294| 55.4k| ctx, it, end); 295| | } 296| | else { 297| | from>::template op(get_member(value, get(to_tie(value))), ctx, 298| | it, end); 299| | } 300| 55.4k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 55.4k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav: 484| 39.8k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 39.8k| { 312| 39.8k| static constexpr auto Key = get(reflect::keys); 313| 39.8k| static constexpr auto KeyWithEndQuote = join_v>; 314| 39.8k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 39.8k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 39.6k, False: 234] | Branch (316:36): [True: 39.3k, False: 227] ------------------ 317| 39.3k| it += Length; 318| 39.3k| if constexpr (not Opts.null_terminated) { 319| 39.3k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 39.3k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 39.3k| } 324| | 325| 39.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 0, False: 39.3k] ------------------ 326| 0| return; 327| 0| } 328| 39.3k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 0, False: 39.3k] ------------------ 329| 0| return; 330| 0| } 331| 39.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 0, False: 39.3k] ------------------ 332| 0| return; 333| 0| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 39.3k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 39.3k| } 338| 461| else [[unlikely]] { 339| 461| decode_index_unknown_key(value, ctx, it, end); 340| 461| } 341| 39.8k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 39.3k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 39.3k| else { 273| 39.3k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| 39.3k| else if constexpr (glaze_object_t) { 293| 39.3k| from>::template op(get_member(value, get(reflect::values)), 294| 39.3k| ctx, it, end); 295| | } 296| | else { 297| | from>::template op(get_member(value, get(to_tie(value))), ctx, 298| | it, end); 299| | } 300| 39.3k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 39.3k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav: 484| 84.4k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 311| 84.4k| { 312| 84.4k| static constexpr auto Key = get(reflect::keys); 313| 84.4k| static constexpr auto KeyWithEndQuote = join_v>; 314| 84.4k| static constexpr auto Length = KeyWithEndQuote.size(); 315| | 316| 84.4k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (316:11): [True: 84.2k, False: 202] | Branch (316:36): [True: 80.9k, False: 3.30k] ------------------ 317| 80.9k| it += Length; 318| 80.9k| if constexpr (not Opts.null_terminated) { 319| 80.9k| if (it == end) [[unlikely]] { ------------------ | Branch (319:17): [True: 0, False: 80.9k] ------------------ 320| 0| ctx.error = error_code::unexpected_end; 321| 0| return; 322| 0| } 323| 80.9k| } 324| | 325| 80.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (325:14): [True: 3, False: 80.9k] ------------------ 326| 3| return; 327| 3| } 328| 80.9k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (328:14): [True: 1.41k, False: 79.4k] ------------------ 329| 1.41k| return; 330| 1.41k| } 331| 79.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (331:14): [True: 2, False: 79.4k] ------------------ 332| 2| return; 333| 2| } 334| | 335| | // The hash path has already consumed the whitespace before the value 336| 79.4k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 337| 79.4k| } 338| 3.50k| else [[unlikely]] { 339| 3.50k| decode_index_unknown_key(value, ctx, it, end); 340| 3.50k| } 341| 84.4k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 245| 79.4k| { 246| | // Check for null value skipping on read 247| | if constexpr (check_skip_null_members_on_read(Opts)) { 248| | if (*it == 'n') { 249| | ++it; 250| | if constexpr (not Opts.null_terminated) { 251| | if (it == end) [[unlikely]] { 252| | ctx.error = error_code::unexpected_end; 253| | return; 254| | } 255| | } 256| | match<"ull", Opts>(ctx, it, end); 257| | if (bool(ctx.error)) [[unlikely]] 258| | return; 259| | // Successfully matched "null", skip it 260| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 261| | ((selected_index = I), ...); // Mark as handled even if skipped 262| | } 263| | return; 264| | } 265| | } 266| | 267| | if constexpr (skipped_by_meta) { 268| | skip_value::op(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; // Propagate error from skip_value 271| | } 272| 79.4k| else { 273| 79.4k| using V = refl_t; 274| | 275| | if constexpr (const_value_v) { 276| | if constexpr (check_error_on_const_read(Opts)) { 277| | ctx.error = error_code::attempt_const_read; 278| | } 279| | else { 280| | // do not read anything into the const value 281| | skip_value::op(ctx, it, end); 282| | } 283| | } 284| | else if constexpr (is_function_ptr_or_ref) { 285| | // Function pointers cannot be deserialized from JSON. 286| | // When write_function_pointers is enabled the writer emits a type-name string, 287| | // but there is nothing meaningful to reconstruct on read — just skip the value. 288| | // When write_function_pointers is off the key is never written, so this branch 289| | // is unreachable in that case. 290| | skip_value::op(ctx, it, end); 291| | } 292| 79.4k| else if constexpr (glaze_object_t) { 293| 79.4k| from>::template op(get_member(value, get(reflect::values)), 294| 79.4k| ctx, it, end); 295| | } 296| | else { 297| | from>::template op(get_member(value, get(to_tie(value))), ctx, 298| | it, end); 299| | } 300| 79.4k| } 301| | 302| | // The key was present and handled, even when the value itself was skipped 303| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 304| | ((selected_index = I), ...); 305| | } 306| 79.4k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 4065| 79.4k| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 79.4k| else { 4070| 79.4k| read_deduced(value, ctx, it, end); 4071| 79.4k| } 4072| 79.4k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 4076| 79.4k| { 4077| 79.4k| constexpr auto Opts = ws_handled_off(); 4078| 79.4k| if constexpr (variant_is_auto_deducible()) { 4079| | if constexpr (not check_ws_handled(Options)) { 4080| | if (skip_ws(ctx, it, end)) { 4081| | return; 4082| | } 4083| | } 4084| | 4085| 79.4k| switch (*it) { 4086| 232| case '\0': ------------------ | Branch (4086:13): [True: 232, False: 79.2k] ------------------ 4087| 232| ctx.error = error_code::unexpected_end; 4088| 232| return; 4089| 1.35k| case '{': { ------------------ | Branch (4089:13): [True: 1.35k, False: 78.1k] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 1.35k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 1.35k] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 1.35k| ++it; 4099| 1.35k| if constexpr (not Opts.null_terminated) { 4100| 1.35k| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 1, False: 1.35k] ------------------ 4101| 1| ctx.error = error_code::unexpected_end; 4102| 1| return; 4103| 1| } 4104| 1.35k| } 4105| 1.35k| using type_counts = variant_type_count; 4106| 1.35k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| 1.35k| if constexpr (n_object_candidates < 1) { 4108| 1.35k| ctx.error = error_code::no_matching_variant_type; 4109| 1.35k| return; 4110| | } 4111| | else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| | constexpr auto first_idx = variant_first_object_candidate_v; 4113| | using V = std::variant_alternative_t; 4114| | if (!std::holds_alternative(value)) value = V{}; 4115| | parse::op()>(std::get(value), ctx, it, end); 4116| | return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 1.35k| } 4801| 4.03k| case '[': ------------------ | Branch (4801:13): [True: 4.03k, False: 75.4k] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 4.03k| process_variant_alternatives::template op(value, ctx, it, end); 4804| 4.03k| break; 4805| 7.28k| case '"': { ------------------ | Branch (4805:13): [True: 7.28k, False: 72.2k] ------------------ 4806| 7.28k| process_variant_alternatives::template op(value, ctx, it, end); 4807| 7.28k| break; 4808| 1.35k| } 4809| 698| case 't': ------------------ | Branch (4809:13): [True: 698, False: 78.7k] ------------------ 4810| 1.81k| case 'f': { ------------------ | Branch (4810:13): [True: 1.11k, False: 78.3k] ------------------ 4811| 1.81k| process_variant_alternatives::template op(value, ctx, it, end); 4812| 1.81k| break; 4813| 698| } 4814| 1.46k| case 'n': ------------------ | Branch (4814:13): [True: 1.46k, False: 78.0k] ------------------ 4815| | if constexpr (variant_count_v == 0) { 4816| | ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| 1.46k| else { 4819| 1.46k| constexpr auto first_idx = variant_first_index_v; 4820| 1.46k| using V = std::variant_alternative_t; 4821| 1.46k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4821:23): [True: 195, False: 1.27k] ------------------ 4822| 1.46k| match<"null", Opts>(ctx, it, end); 4823| 1.46k| } 4824| 1.46k| break; 4825| 63.3k| default: { ------------------ | Branch (4825:13): [True: 63.3k, False: 16.1k] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 63.3k| process_variant_alternatives::template op(value, ctx, it, end); 4828| 63.3k| } 4829| 79.4k| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 79.4k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3725| 6.16k| { 3726| 6.16k| constexpr auto category_count = variant_count_v; 3727| | 3728| 6.16k| if constexpr (category_count == 0) { 3729| 6.16k| ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| | else { 3732| | constexpr auto N = std::variant_size_v; 3733| | constexpr auto const_count = variant_filtered_count_v; 3734| | constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| | bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| | bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| | if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| | size_t non_const_idx = 0; 3793| | 3794| | for_each([&]() { 3795| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| | return; 3797| | } 3798| | using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| | }); 3850| | if (!found_match) { 3851| | if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| | } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| | } 3864| 6.16k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3725| 8.39k| { 3726| 8.39k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 8.39k| else { 3732| 8.39k| constexpr auto N = std::variant_size_v; 3733| 8.39k| constexpr auto const_count = variant_filtered_count_v; 3734| 8.39k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 8.39k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 8.39k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 8.39k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 8.39k| size_t non_const_idx = 0; 3793| | 3794| 8.39k| for_each([&]() { 3795| 8.39k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 8.39k| return; 3797| 8.39k| } 3798| 8.39k| using V = std::variant_alternative_t; 3799| 8.39k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 8.39k| auto copy_it{it}; 3801| 8.39k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 8.39k| if (!std::holds_alternative(value)) { 3803| 8.39k| value = V{}; 3804| 8.39k| } 3805| 8.39k| parse::op()>(std::get(value), ctx, it, end); 3806| 8.39k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 8.39k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 8.39k| } 3809| 8.39k| if (!bool(ctx.error)) { 3810| 8.39k| found_match = true; 3811| 8.39k| } 3812| 8.39k| else if constexpr (not Options.null_terminated) { 3813| 8.39k| constexpr bool is_complete_type = 3814| 8.39k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 8.39k| if constexpr (is_complete_type) { 3817| 8.39k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 8.39k| found_match = true; 3819| 8.39k| ctx.error = error_code::none; 3820| 8.39k| } 3821| 8.39k| else { 3822| 8.39k| it = copy_it; 3823| 8.39k| rewind_depth(ctx, copy_depth); 3824| 8.39k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 8.39k| not variant_alternative_exhausted(ctx)) { 3826| 8.39k| ctx.error = error_code::none; 3827| 8.39k| } 3828| 8.39k| } 3829| 8.39k| } 3830| 8.39k| else { 3831| 8.39k| it = copy_it; 3832| 8.39k| rewind_depth(ctx, copy_depth); 3833| 8.39k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 8.39k| not variant_alternative_exhausted(ctx)) { 3835| 8.39k| ctx.error = error_code::none; 3836| 8.39k| } 3837| 8.39k| } 3838| 8.39k| } 3839| 8.39k| else { 3840| 8.39k| it = copy_it; 3841| 8.39k| rewind_depth(ctx, copy_depth); 3842| 8.39k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 8.39k| not variant_alternative_exhausted(ctx)) { 3844| 8.39k| ctx.error = error_code::none; 3845| 8.39k| } 3846| 8.39k| } 3847| 8.39k| ++non_const_idx; 3848| 8.39k| } 3849| 8.39k| }); 3850| 8.39k| if (!found_match) { ------------------ | Branch (3850:20): [True: 1.19k, False: 7.20k] ------------------ 3851| 1.19k| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 1.19k| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 8.39k| } 3864| 8.39k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 8.39k| for_each([&]() { 3795| 8.39k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 8.39k] | Branch (3795:38): [True: 0, False: 8.39k] | Branch (3795:51): [True: 0, False: 8.39k] ------------------ 3796| 0| return; 3797| 0| } 3798| 8.39k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 8.39k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 8.39k| for_each([&]() { 3795| 8.39k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 8.39k] | Branch (3795:38): [True: 0, False: 8.39k] | Branch (3795:51): [True: 0, False: 8.39k] ------------------ 3796| 0| return; 3797| 0| } 3798| 8.39k| using V = std::variant_alternative_t; 3799| 8.39k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 8.39k| auto copy_it{it}; 3801| 8.39k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 8.39k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 8.05k, False: 343] ------------------ 3803| 8.05k| value = V{}; 3804| 8.05k| } 3805| 8.39k| parse::op()>(std::get(value), ctx, it, end); 3806| 8.39k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 1.19k, False: 7.20k] | Branch (3806:45): [True: 0, False: 1.19k] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 8.39k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 7.20k, False: 1.19k] ------------------ 3810| 7.20k| found_match = true; 3811| 7.20k| } 3812| 1.19k| else if constexpr (not Options.null_terminated) { 3813| 1.19k| constexpr bool is_complete_type = 3814| 1.19k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [Folded, False: 0] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [Folded, False: 0] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| 1.19k| else { 3831| 1.19k| it = copy_it; 3832| 1.19k| rewind_depth(ctx, copy_depth); 3833| 1.19k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3833:32): [True: 0, False: 1.19k] | Branch (3833:71): [True: 0, False: 0] ------------------ 3834| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3834:32): [True: 0, False: 0] ------------------ 3835| 0| ctx.error = error_code::none; 3836| 0| } 3837| 1.19k| } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 8.39k| ++non_const_idx; 3848| 8.39k| } 3849| 8.39k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 8.39k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 8.39k| else { 60| 8.39k| using V = std::remove_cvref_t; 61| 8.39k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 8.39k| end); 63| 8.39k| } 64| 8.39k| } _ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_: 1864| 8.39k| { 1865| 8.39k| if constexpr (!check_opening_handled(Opts)) { 1866| | if constexpr (!check_ws_handled(Opts)) { 1867| | if (skip_ws(ctx, it, end)) { 1868| | return; 1869| | } 1870| | } 1871| | 1872| 8.39k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1872:17): [True: 2, False: 8.39k] ------------------ 1873| 2| return; 1874| 2| } 1875| 8.39k| } 1876| | 1877| 8.39k| auto start = it; 1878| 8.39k| skip_string_view(ctx, it, end); 1879| 8.39k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1879:14): [True: 5, False: 8.38k] ------------------ 1880| 5| return; 1881| | 1882| 8.38k| if (validate_utf8_span(ctx, start, it)) [[unlikely]] { ------------------ | Branch (1882:14): [True: 76, False: 8.31k] ------------------ 1883| 76| return; 1884| 76| } 1885| | 1886| 8.31k| if constexpr (string_view_t) { 1887| 8.31k| if constexpr (!Transient) { 1888| 8.31k| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 8.31k| static_assert(!::glz::has_streaming_state, \ | | 243| 8.31k| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 8.31k| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 8.31k| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 8.31k| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 8.31k| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 8.31k| "container), or read from a buffer that holds the whole document.") ------------------ 1889| 8.31k| } 1890| 8.31k| using value_type = typename std::decay_t::value_type; 1891| | if constexpr (std::same_as) { 1892| | value = {reinterpret_cast(start), size_t(it - start)}; 1893| | } 1894| 8.31k| else { 1895| 8.31k| value = {start, size_t(it - start)}; 1896| 8.31k| } 1897| | } 1898| | else if constexpr (char_array_t) { 1899| | const size_t n = it - start; 1900| | if ((n + 1) > sizeof(value)) { 1901| | ctx.error = error_code::unexpected_end; 1902| | return; 1903| | } 1904| | std::memcpy(value, start, n); 1905| | value[n] = '\0'; 1906| | } 1907| | else if constexpr (array_char_t) { 1908| | const size_t n = it - start; 1909| | if ((n + 1) > value.size()) { 1910| | ctx.error = error_code::unexpected_end; 1911| | return; 1912| | } 1913| | std::memcpy(value.data(), start, n); 1914| | value[n] = '\0'; 1915| | } 1916| | else if constexpr (static_string_t) { 1917| | const size_t n = it - start; 1918| | if (n > value.capacity()) { 1919| | ctx.error = error_code::unexpected_end; 1920| | return; 1921| | } 1922| | value.assign(start, n); 1923| | } 1924| 8.31k| ++it; // skip closing quote 1925| 8.31k| if constexpr (not Opts.null_terminated) { 1926| 8.31k| if (it == end) { ------------------ | Branch (1926:17): [True: 1.11k, False: 7.20k] ------------------ 1927| 1.11k| ctx.error = error_code::end_reached; 1928| 1.11k| return; 1929| 1.11k| } 1930| 8.31k| } 1931| 8.31k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3794| 8.39k| for_each([&]() { 3795| 8.39k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 7.20k, False: 1.19k] | Branch (3795:38): [True: 0, False: 1.19k] | Branch (3795:51): [True: 0, False: 1.19k] ------------------ 3796| 7.20k| return; 3797| 7.20k| } 3798| 1.19k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 1.19k| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3725| 2.34k| { 3726| 2.34k| constexpr auto category_count = variant_count_v; 3727| | 3728| 2.34k| if constexpr (category_count == 0) { 3729| 2.34k| ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| | else { 3732| | constexpr auto N = std::variant_size_v; 3733| | constexpr auto const_count = variant_filtered_count_v; 3734| | constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| | bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| | bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| | if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| | size_t non_const_idx = 0; 3793| | 3794| | for_each([&]() { 3795| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| | return; 3797| | } 3798| | using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| | }); 3850| | if (!found_match) { 3851| | if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| | } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| | } 3864| 2.34k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3725| 72.3k| { 3726| 72.3k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 72.3k| else { 3732| 72.3k| constexpr auto N = std::variant_size_v; 3733| 72.3k| constexpr auto const_count = variant_filtered_count_v; 3734| 72.3k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 72.3k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 72.3k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 72.3k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 72.3k| size_t non_const_idx = 0; 3793| | 3794| 72.3k| for_each([&]() { 3795| 72.3k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 72.3k| return; 3797| 72.3k| } 3798| 72.3k| using V = std::variant_alternative_t; 3799| 72.3k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 72.3k| auto copy_it{it}; 3801| 72.3k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 72.3k| if (!std::holds_alternative(value)) { 3803| 72.3k| value = V{}; 3804| 72.3k| } 3805| 72.3k| parse::op()>(std::get(value), ctx, it, end); 3806| 72.3k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 72.3k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 72.3k| } 3809| 72.3k| if (!bool(ctx.error)) { 3810| 72.3k| found_match = true; 3811| 72.3k| } 3812| 72.3k| else if constexpr (not Options.null_terminated) { 3813| 72.3k| constexpr bool is_complete_type = 3814| 72.3k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 72.3k| if constexpr (is_complete_type) { 3817| 72.3k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 72.3k| found_match = true; 3819| 72.3k| ctx.error = error_code::none; 3820| 72.3k| } 3821| 72.3k| else { 3822| 72.3k| it = copy_it; 3823| 72.3k| rewind_depth(ctx, copy_depth); 3824| 72.3k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 72.3k| not variant_alternative_exhausted(ctx)) { 3826| 72.3k| ctx.error = error_code::none; 3827| 72.3k| } 3828| 72.3k| } 3829| 72.3k| } 3830| 72.3k| else { 3831| 72.3k| it = copy_it; 3832| 72.3k| rewind_depth(ctx, copy_depth); 3833| 72.3k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 72.3k| not variant_alternative_exhausted(ctx)) { 3835| 72.3k| ctx.error = error_code::none; 3836| 72.3k| } 3837| 72.3k| } 3838| 72.3k| } 3839| 72.3k| else { 3840| 72.3k| it = copy_it; 3841| 72.3k| rewind_depth(ctx, copy_depth); 3842| 72.3k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 72.3k| not variant_alternative_exhausted(ctx)) { 3844| 72.3k| ctx.error = error_code::none; 3845| 72.3k| } 3846| 72.3k| } 3847| 72.3k| ++non_const_idx; 3848| 72.3k| } 3849| 72.3k| }); 3850| 72.3k| if (!found_match) { ------------------ | Branch (3850:20): [True: 17.9k, False: 54.4k] ------------------ 3851| 17.9k| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 17.9k| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 72.3k| } 3864| 72.3k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 72.3k| for_each([&]() { 3795| 72.3k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 72.3k] | Branch (3795:38): [True: 0, False: 72.3k] | Branch (3795:51): [True: 0, False: 72.3k] ------------------ 3796| 0| return; 3797| 0| } 3798| 72.3k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 72.3k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 72.3k| for_each([&]() { 3795| 72.3k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 72.3k] | Branch (3795:38): [True: 0, False: 72.3k] | Branch (3795:51): [True: 0, False: 72.3k] ------------------ 3796| 0| return; 3797| 0| } 3798| 72.3k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 72.3k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3794| 72.3k| for_each([&]() { 3795| 72.3k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 72.3k] | Branch (3795:38): [True: 0, False: 72.3k] | Branch (3795:51): [True: 0, False: 72.3k] ------------------ 3796| 0| return; 3797| 0| } 3798| 72.3k| using V = std::variant_alternative_t; 3799| 72.3k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 72.3k| auto copy_it{it}; 3801| 72.3k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 72.3k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 55.6k, False: 16.7k] ------------------ 3803| 55.6k| value = V{}; 3804| 55.6k| } 3805| 72.3k| parse::op()>(std::get(value), ctx, it, end); 3806| 72.3k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 19.8k, False: 52.4k] | Branch (3806:45): [True: 0, False: 19.8k] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 72.3k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 52.4k, False: 19.8k] ------------------ 3810| 52.4k| found_match = true; 3811| 52.4k| } 3812| 19.8k| else if constexpr (not Options.null_terminated) { 3813| 19.8k| constexpr bool is_complete_type = 3814| 19.8k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [True: 19.8k, Folded] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [Folded, False: 0] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| 19.8k| if constexpr (is_complete_type) { 3817| 19.8k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3817:32): [True: 1.92k, False: 17.9k] | Branch (3817:72): [True: 1.92k, False: 0] | Branch (3817:88): [True: 1.92k, False: 0] ------------------ 3818| 1.92k| found_match = true; 3819| 1.92k| ctx.error = error_code::none; 3820| 1.92k| } 3821| 17.9k| else { 3822| 17.9k| it = copy_it; 3823| 17.9k| rewind_depth(ctx, copy_depth); 3824| 17.9k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3824:35): [True: 0, False: 17.9k] | Branch (3824:74): [True: 0, False: 0] ------------------ 3825| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3825:35): [True: 0, False: 0] ------------------ 3826| 0| ctx.error = error_code::none; 3827| 0| } 3828| 17.9k| } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 72.3k| ++non_const_idx; 3848| 72.3k| } 3849| 72.3k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERlTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 72.3k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 72.3k| else { 60| 72.3k| using V = std::remove_cvref_t; 61| 72.3k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 72.3k| end); 63| 72.3k| } 64| 72.3k| } _ZN3glz4fromILj10ElE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRlTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 767| 72.3k| { 768| | if constexpr (check_quoted_num(Opts)) { 769| | if (skip_ws(ctx, it, end)) { 770| | return; 771| | } 772| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 773| | return; 774| | } 775| | } 776| | 777| | if constexpr (!check_ws_handled(Opts)) { 778| | if (skip_ws(ctx, it, end)) { 779| | return; 780| | } 781| | } 782| | 783| 72.3k| using V = std::decay_t; 784| 72.3k| if constexpr (int_t) { 785| 72.3k| static_assert(sizeof(*it) == sizeof(char)); 786| | 787| | if constexpr (Opts.null_terminated) { 788| | if (not glz::atoi(value, it)) [[unlikely]] { 789| | ctx.error = error_code::parse_number_failure; 790| | return; 791| | } 792| | } 793| 72.3k| else { 794| 72.3k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (794:20): [True: 17.9k, False: 54.4k] ------------------ 795| 17.9k| ctx.error = error_code::parse_number_failure; 796| 17.9k| return; 797| 17.9k| } 798| 72.3k| } 799| | } 800| | else { 801| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 802| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 803| | if constexpr (is_float128) { 804| | auto [ptr, ec] = std::from_chars(it, end, value); 805| | if (ec != std::errc()) { 806| | ctx.error = error_code::parse_number_failure; 807| | return; 808| | } 809| | it = ptr; 810| | } 811| | else 812| |#endif 813| | { 814| | if constexpr (std::is_volatile_v>) { 815| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 816| | // place 817| | V temp; 818| | if constexpr (is_size_optimized(Opts)) { 819| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 820| | if (ec != std::errc{}) [[unlikely]] { 821| | ctx.error = error_code::parse_number_failure; 822| | return; 823| | } 824| | it = ptr; 825| | } 826| | else { 827| | auto [ptr, ec] = glz::from_chars(it, end, temp); 828| | if (ec != std::errc()) [[unlikely]] { 829| | ctx.error = error_code::parse_number_failure; 830| | return; 831| | } 832| | it = ptr; 833| | } 834| | value = temp; 835| | } 836| | else { 837| | if constexpr (is_size_optimized(Opts)) { 838| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 839| | if (ec != std::errc{}) [[unlikely]] { 840| | ctx.error = error_code::parse_number_failure; 841| | return; 842| | } 843| | it = ptr; 844| | } 845| | else { 846| | auto [ptr, ec] = glz::from_chars(it, end, value); 847| | if (ec != std::errc()) [[unlikely]] { 848| | ctx.error = error_code::parse_number_failure; 849| | return; 850| | } 851| | it = ptr; 852| | } 853| | } 854| | } 855| | } 856| | 857| | if constexpr (check_quoted_num(Opts)) { 858| | if constexpr (not Opts.null_terminated) { 859| | if (it == end) [[unlikely]] { 860| | ctx.error = error_code::unexpected_end; 861| | return; 862| | } 863| | } 864| | if (match<'"'>(ctx, it)) { 865| | return; 866| | } 867| | if constexpr (not Opts.null_terminated) { 868| | if (it == end) { 869| | ctx.error = error_code::end_reached; 870| | return; 871| | } 872| | } 873| | } 874| 72.3k| else { 875| 72.3k| if constexpr (not Opts.null_terminated) { 876| 72.3k| if (it == end) { ------------------ | Branch (876:20): [True: 1.92k, False: 70.4k] ------------------ 877| 1.92k| ctx.error = error_code::end_reached; 878| 1.92k| return; 879| 1.92k| } 880| 72.3k| } 881| 72.3k| } 882| 72.3k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERNS_4skipETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 49| 317k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 317k| else { 60| 317k| using V = std::remove_cvref_t; 61| 317k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 317k| end); 63| 317k| } 64| 317k| } _ZN3glz4fromILj10ENS_4skipEE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERS1_TkNS_10is_contextERNS_7contextEJRPKcSC_EEEvOT0_OT1_DpOT2_: 564| 317k| { 565| 317k| skip_value::op(ctx, args...); 566| 317k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 14.1k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 14.1k| else { 60| 14.1k| using V = std::remove_cvref_t; 61| 14.1k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 14.1k| end); 63| 14.1k| } 64| 14.1k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 4065| 14.1k| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 14.1k| else { 4070| 14.1k| read_deduced(value, ctx, it, end); 4071| 14.1k| } 4072| 14.1k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 4076| 14.1k| { 4077| 14.1k| constexpr auto Opts = ws_handled_off(); 4078| 14.1k| if constexpr (variant_is_auto_deducible()) { 4079| 14.1k| if constexpr (not check_ws_handled(Options)) { 4080| 14.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (4080:20): [True: 0, False: 14.1k] ------------------ 4081| 0| return; 4082| 0| } 4083| 14.1k| } 4084| | 4085| 14.1k| switch (*it) { 4086| 0| case '\0': ------------------ | Branch (4086:13): [True: 0, False: 14.1k] ------------------ 4087| 0| ctx.error = error_code::unexpected_end; 4088| 0| return; 4089| 1.17k| case '{': { ------------------ | Branch (4089:13): [True: 1.17k, False: 13.0k] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 1.17k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 1.17k] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 1.17k| ++it; 4099| 1.17k| if constexpr (not Opts.null_terminated) { 4100| 1.17k| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 0, False: 1.17k] ------------------ 4101| 0| ctx.error = error_code::unexpected_end; 4102| 0| return; 4103| 0| } 4104| 1.17k| } 4105| 1.17k| using type_counts = variant_type_count; 4106| 1.17k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| 1.17k| if constexpr (n_object_candidates < 1) { 4108| 1.17k| ctx.error = error_code::no_matching_variant_type; 4109| 1.17k| return; 4110| | } 4111| | else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| | constexpr auto first_idx = variant_first_object_candidate_v; 4113| | using V = std::variant_alternative_t; 4114| | if (!std::holds_alternative(value)) value = V{}; 4115| | parse::op()>(std::get(value), ctx, it, end); 4116| | return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 1.17k| } 4801| 2.13k| case '[': ------------------ | Branch (4801:13): [True: 2.13k, False: 12.0k] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 2.13k| process_variant_alternatives::template op(value, ctx, it, end); 4804| 2.13k| break; 4805| 1.11k| case '"': { ------------------ | Branch (4805:13): [True: 1.11k, False: 13.0k] ------------------ 4806| 1.11k| process_variant_alternatives::template op(value, ctx, it, end); 4807| 1.11k| break; 4808| 1.17k| } 4809| 333| case 't': ------------------ | Branch (4809:13): [True: 333, False: 13.8k] ------------------ 4810| 535| case 'f': { ------------------ | Branch (4810:13): [True: 202, False: 13.9k] ------------------ 4811| 535| process_variant_alternatives::template op(value, ctx, it, end); 4812| 535| break; 4813| 333| } 4814| 208| case 'n': ------------------ | Branch (4814:13): [True: 208, False: 13.9k] ------------------ 4815| | if constexpr (variant_count_v == 0) { 4816| | ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| 208| else { 4819| 208| constexpr auto first_idx = variant_first_index_v; 4820| 208| using V = std::variant_alternative_t; 4821| 208| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4821:23): [True: 0, False: 208] ------------------ 4822| 208| match<"null", Opts>(ctx, it, end); 4823| 208| } 4824| 208| break; 4825| 9.02k| default: { ------------------ | Branch (4825:13): [True: 9.02k, False: 5.16k] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 9.02k| process_variant_alternatives::template op(value, ctx, it, end); 4828| 9.02k| } 4829| 14.1k| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 14.1k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 49| 63.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 63.0k| else { 60| 63.0k| using V = std::remove_cvref_t; 61| 63.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 63.0k| end); 63| 63.0k| } 64| 63.0k| } _ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 150| 63.0k| { 151| 63.0k| using V = std::decay_t(), meta_wrapper_v))>; 152| 63.0k| from::template op(get_member(std::forward(value), meta_wrapper_v), 153| 63.0k| std::forward(ctx), std::forward(it), end); 154| 63.0k| } _ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_: 4065| 63.0k| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 63.0k| else { 4070| 63.0k| read_deduced(value, ctx, it, end); 4071| 63.0k| } 4072| 63.0k| } _ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_: 4076| 63.0k| { 4077| 63.0k| constexpr auto Opts = ws_handled_off(); 4078| 63.0k| if constexpr (variant_is_auto_deducible()) { 4079| 63.0k| if constexpr (not check_ws_handled(Options)) { 4080| 63.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (4080:20): [True: 0, False: 63.0k] ------------------ 4081| 0| return; 4082| 0| } 4083| 63.0k| } 4084| | 4085| 63.0k| switch (*it) { 4086| 0| case '\0': ------------------ | Branch (4086:13): [True: 0, False: 63.0k] ------------------ 4087| 0| ctx.error = error_code::unexpected_end; 4088| 0| return; 4089| 45.1k| case '{': { ------------------ | Branch (4089:13): [True: 45.1k, False: 17.8k] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 45.1k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 45.1k] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 45.1k| ++it; 4099| 45.1k| if constexpr (not Opts.null_terminated) { 4100| 45.1k| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 0, False: 45.1k] ------------------ 4101| 0| ctx.error = error_code::unexpected_end; 4102| 0| return; 4103| 0| } 4104| 45.1k| } 4105| 45.1k| using type_counts = variant_type_count; 4106| 45.1k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| | if constexpr (n_object_candidates < 1) { 4108| | ctx.error = error_code::no_matching_variant_type; 4109| | return; 4110| | } 4111| 45.1k| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| 45.1k| constexpr auto first_idx = variant_first_object_candidate_v; 4113| 45.1k| using V = std::variant_alternative_t; 4114| 45.1k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4114:23): [True: 45.1k, False: 0] ------------------ 4115| 45.1k| parse::op()>(std::get(value), ctx, it, end); 4116| 45.1k| return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 45.1k| } 4801| 17.8k| case '[': ------------------ | Branch (4801:13): [True: 17.8k, False: 45.1k] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 17.8k| process_variant_alternatives::template op(value, ctx, it, end); 4804| 17.8k| break; 4805| 0| case '"': { ------------------ | Branch (4805:13): [True: 0, False: 63.0k] ------------------ 4806| 0| process_variant_alternatives::template op(value, ctx, it, end); 4807| 0| break; 4808| 45.1k| } 4809| 0| case 't': ------------------ | Branch (4809:13): [True: 0, False: 63.0k] ------------------ 4810| 0| case 'f': { ------------------ | Branch (4810:13): [True: 0, False: 63.0k] ------------------ 4811| 0| process_variant_alternatives::template op(value, ctx, it, end); 4812| 0| break; 4813| 0| } 4814| 0| case 'n': ------------------ | Branch (4814:13): [True: 0, False: 63.0k] ------------------ 4815| | if constexpr (variant_count_v == 0) { 4816| | ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| 0| else { 4819| 0| constexpr auto first_idx = variant_first_index_v; 4820| 0| using V = std::variant_alternative_t; 4821| 0| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4821:23): [True: 0, False: 0] ------------------ 4822| 0| match<"null", Opts>(ctx, it, end); 4823| 0| } 4824| 0| break; 4825| 0| default: { ------------------ | Branch (4825:13): [True: 0, False: 63.0k] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 0| process_variant_alternatives::template op(value, ctx, it, end); 4828| 0| } 4829| 63.0k| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 63.0k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERNS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES4_EEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 501k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 501k| else { 60| 501k| using V = std::remove_cvref_t; 61| 501k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 501k| end); 63| 501k| } 64| 501k| } _ZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_: 3044| 501k| { 3045| 501k| static constexpr auto num_members = reflect::size; 3046| | 3047| 501k| static constexpr auto Opts = opening_handled_off()>(); 3048| | if constexpr (!check_opening_handled(Options)) { 3049| | if constexpr (!check_ws_handled(Options)) { 3050| | if (skip_ws(ctx, it, end)) { 3051| | return; 3052| | } 3053| | } 3054| | if (match_invalid_end<'{', Opts>(ctx, it, end)) { 3055| | return; 3056| | } 3057| | if constexpr (not Opts.null_terminated) { 3058| | if (it == end) [[unlikely]] { 3059| | ctx.error = error_code::unexpected_end; 3060| | return; 3061| | } 3062| | } 3063| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3064| | // released at each syntactic close below 3065| | if (enter_depth(ctx)) [[unlikely]] { 3066| | return; 3067| | } 3068| | } 3069| 501k| const auto ws_start = it; 3070| 501k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3070:14): [True: 0, False: 501k] ------------------ 3071| 0| return; 3072| 0| } 3073| 501k| const size_t ws_size = size_t(it - ws_start); 3074| | 3075| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3076| | if constexpr (not tag.sv().empty()) { 3077| | if (*it == '"') { 3078| | ++it; 3079| | if constexpr (not Opts.null_terminated) { 3080| | if (it == end) [[unlikely]] { 3081| | ctx.error = error_code::unexpected_end; 3082| | return; 3083| | } 3084| | } 3085| | 3086| | const auto start = it; 3087| | skip_string_view(ctx, it, end); 3088| | if (bool(ctx.error)) [[unlikely]] 3089| | return; 3090| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3091| | return; 3092| | const sv key{start, size_t(it - start)}; 3093| | ++it; 3094| | if constexpr (not Opts.null_terminated) { 3095| | if (it == end) [[unlikely]] { 3096| | ctx.error = error_code::unexpected_end; 3097| | return; 3098| | } 3099| | } 3100| | 3101| | if (key == tag.sv()) { 3102| | if (parse_ws_colon(ctx, it, end)) { 3103| | return; 3104| | } 3105| | 3106| | parse::handle_unknown(key, value, ctx, it, end); 3107| | if (bool(ctx.error)) [[unlikely]] 3108| | return; 3109| | 3110| | if (skip_ws(ctx, it, end)) { 3111| | return; 3112| | } 3113| | } 3114| | else { 3115| | ctx.error = error_code::unknown_key; 3116| | return; 3117| | } 3118| | } 3119| | } 3120| | 3121| | if (*it == '}') [[likely]] { 3122| | --ctx.depth; 3123| | if constexpr (glaze_object_t || reflectable) { 3124| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3125| | auto wrapper = self_constraint_v(value); 3126| | from::template op()>(wrapper, ctx, it, end); 3127| | if (bool(ctx.error)) { 3128| | return; 3129| | } 3130| | } 3131| | } 3132| | ++it; 3133| | if constexpr (not Opts.null_terminated) { 3134| | if (it == end) { 3135| | ctx.error = error_code::end_reached; 3136| | return; 3137| | } 3138| | } 3139| | if constexpr (Opts.partial_read) { 3140| | ctx.error = error_code::partial_read_complete; 3141| | } 3142| | return; 3143| | } 3144| | ctx.error = error_code::unknown_key; 3145| | return; 3146| | } 3147| 501k| else { 3148| 501k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| 501k| if constexpr ((glaze_object_t || reflectable) && 3150| 501k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| 501k| return bit_array{}; 3152| 501k| } 3153| 501k| else { 3154| 501k| return nullptr; 3155| 501k| } 3156| 501k| }(); 3157| | 3158| 501k| size_t read_count{}; // for partial_read 3159| | 3160| 501k| bool first = true; 3161| 1.98M| while (true) { ------------------ | Branch (3161:20): [True: 1.93M, Folded] ------------------ 3162| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3163| | static constexpr bit_array all_fields = [] { 3164| | bit_array arr{}; 3165| | for (size_t i = 0; i < num_members; ++i) { 3166| | arr[i] = true; 3167| | } 3168| | return arr; 3169| | }(); 3170| | 3171| | if ((all_fields & fields) == all_fields) { 3172| | ctx.error = error_code::partial_read_complete; 3173| | --ctx.depth; // as above: an early success still closes this level 3174| | return; 3175| | } 3176| | } 3177| | 3178| | // Streaming refill point: at start of each iteration, ensure buffer has data 3179| | if constexpr (has_streaming_state) { 3180| | if (ctx.stream.enabled()) { 3181| | const size_t consumed = static_cast(it - ctx.stream.data()); 3182| | const size_t remaining = ctx.stream.size() - consumed; 3183| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3184| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3185| | const char* new_it; 3186| | const char* new_end; 3187| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3188| | it = new_it; 3189| | end = new_end; 3190| | if (it >= end && ctx.stream.at_eof()) { 3191| | ctx.error = error_code::unexpected_end; 3192| | return; 3193| | } 3194| | } 3195| | } 3196| | } 3197| | 3198| 1.93M| if (*it == '}') { ------------------ | Branch (3198:20): [True: 455k, False: 1.48M] ------------------ 3199| 455k| --ctx.depth; 3200| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3201| | constexpr auto req_fields = required_fields(); 3202| | if ((req_fields & fields) != req_fields) { 3203| | for (size_t i = 0; i < num_members; ++i) { 3204| | if (not fields[i] && req_fields[i]) { 3205| | ctx.custom_error_message = reflect::keys[i]; 3206| | // We just return the first missing key in order to avoid heap allocations 3207| | break; 3208| | } 3209| | } 3210| | 3211| | ctx.error = error_code::missing_key; 3212| | return; 3213| | } 3214| | } 3215| | if constexpr (glaze_object_t || reflectable) { 3216| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3217| | auto wrapper = self_constraint_v(value); 3218| | from::template op()>(wrapper, ctx, it, end); 3219| | if (bool(ctx.error)) { 3220| | return; 3221| | } 3222| | } 3223| | } 3224| 455k| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3225| 455k| if constexpr (not Opts.null_terminated) { 3226| 455k| if (it == end) { ------------------ | Branch (3226:26): [True: 27.8k, False: 427k] ------------------ 3227| 27.8k| ctx.error = error_code::end_reached; 3228| 27.8k| return; 3229| 27.8k| } 3230| 455k| } 3231| 427k| return; 3232| 455k| } 3233| 1.48M| else if (first) { ------------------ | Branch (3233:25): [True: 501k, False: 979k] ------------------ 3234| 501k| first = false; 3235| 501k| } 3236| 979k| else { 3237| 979k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3237:23): [True: 0, False: 979k] ------------------ 3238| 0| return; 3239| 0| } 3240| 979k| if constexpr (not Opts.null_terminated) { 3241| 979k| if (it == end) [[unlikely]] { ------------------ | Branch (3241:26): [True: 0, False: 979k] ------------------ 3242| 0| ctx.error = error_code::unexpected_end; 3243| 0| return; 3244| 0| } 3245| 979k| } 3246| | 3247| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3248| | (!Opts.comments)) { 3249| | if (ws_size && ws_size < size_t(end - it)) { 3250| | skip_matching_ws(ws_start, it, ws_size); 3251| | } 3252| | } 3253| | 3254| 979k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3254:23): [True: 0, False: 979k] ------------------ 3255| 0| return; 3256| 0| } 3257| 979k| } 3258| | 3259| 1.48M| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3259:49): [Folded, False: 0] | Branch (3259:70): [Folded, False: 0] ------------------ 3260| | 3261| | if constexpr (reflection_type && (num_members == 0)) { 3262| | if constexpr (Opts.error_on_unknown_keys) { 3263| | static_assert(false_v, "This should be unreachable"); 3264| | } 3265| | else { 3266| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3267| | return; 3268| | } 3269| | 3270| | // parsing to an empty object, but at this point the JSON presents keys 3271| | 3272| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3273| | // handled by the user. 3274| | 3275| | const auto start = it; 3276| | skip_string_view(ctx, it, end); 3277| | if (bool(ctx.error)) [[unlikely]] 3278| | return; 3279| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3280| | return; 3281| | const sv key{start, size_t(it - start)}; 3282| | ++it; 3283| | if constexpr (not Opts.null_terminated) { 3284| | if (it == end) [[unlikely]] { 3285| | ctx.error = error_code::unexpected_end; 3286| | return; 3287| | } 3288| | } 3289| | 3290| | if (parse_ws_colon(ctx, it, end)) { 3291| | return; 3292| | } 3293| | 3294| | // Check if this key is the variant tag that should be skipped 3295| | if constexpr (not tag.sv().empty()) { 3296| | if (key == tag.sv()) { 3297| | // Skip the tag value 3298| | skip_value::op(ctx, it, end); 3299| | if (bool(ctx.error)) [[unlikely]] 3300| | return; 3301| | resync_window_end(ctx, end); // a streaming skip refills 3302| | if (skip_ws(ctx, it, end)) { 3303| | return; 3304| | } 3305| | continue; 3306| | } 3307| | } 3308| | 3309| | parse::handle_unknown(key, value, ctx, it, end); 3310| | if (bool(ctx.error)) [[unlikely]] 3311| | return; 3312| | if constexpr (not Opts.null_terminated) { 3313| | if (it == end) [[unlikely]] { 3314| | ctx.error = error_code::unexpected_end; 3315| | return; 3316| | } 3317| | } 3318| | if (skip_ws(ctx, it, end)) { 3319| | return; 3320| | } 3321| | } 3322| | } 3323| | else if constexpr (reflection_type) { 3324| | static_assert(bool(hash_info.type)); 3325| | 3326| | if (*it != '"') [[unlikely]] { 3327| | ctx.error = error_code::expected_quote; 3328| | return; 3329| | } 3330| | ++it; 3331| | if constexpr (not Opts.null_terminated) { 3332| | if (it == end) [[unlikely]] { 3333| | ctx.error = error_code::unexpected_end; 3334| | return; 3335| | } 3336| | } 3337| | 3338| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3339| | // For tagged variants we first check to see if the key matches the tag 3340| | // We only need to do this if the tag is not part of the keys 3341| | 3342| | const auto start = it; 3343| | skip_string_view(ctx, it, end); 3344| | if (bool(ctx.error)) [[unlikely]] 3345| | return; 3346| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3347| | return; 3348| | const sv key{start, size_t(it - start)}; 3349| | ++it; 3350| | if constexpr (not Opts.null_terminated) { 3351| | if (it == end) [[unlikely]] { 3352| | ctx.error = error_code::unexpected_end; 3353| | return; 3354| | } 3355| | } 3356| | 3357| | if (key == tag.sv()) { 3358| | if (parse_ws_colon(ctx, it, end)) { 3359| | return; 3360| | } 3361| | 3362| | parse::handle_unknown(key, value, ctx, it, end); 3363| | if (bool(ctx.error)) [[unlikely]] 3364| | return; 3365| | 3366| | if (skip_ws(ctx, it, end)) { 3367| | return; 3368| | } 3369| | continue; 3370| | } 3371| | else { 3372| | it = start; // reset the iterator 3373| | } 3374| | } 3375| | 3376| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3377| | size_t index = num_members; 3378| | parse_and_invoke(value, ctx, it, end, index); 3379| | if (bool(ctx.error)) [[unlikely]] 3380| | return; 3381| | if (index < num_members) { 3382| | fields[index] = true; 3383| | } 3384| | } 3385| | else { 3386| | parse_and_invoke(value, ctx, it, end); 3387| | if (bool(ctx.error)) [[unlikely]] 3388| | return; 3389| | } 3390| | } 3391| 1.48M| else { 3392| | // For types like std::map, std::unordered_map 3393| | 3394| 1.48M| auto reading = [&](auto&& key) { 3395| 1.48M| if constexpr (Opts.partial_read) { 3396| 1.48M| if (auto element = value.find(key); element != value.end()) { 3397| 1.48M| ++read_count; 3398| 1.48M| parse::op()>(element->second, ctx, it, end); 3399| 1.48M| } 3400| 1.48M| else { 3401| 1.48M| skip_value::op(ctx, it, end); 3402| 1.48M| } 3403| 1.48M| } 3404| 1.48M| else { 3405| 1.48M| parse::op()>(value[key], ctx, it, end); 3406| 1.48M| } 3407| 1.48M| }; 3408| | 3409| | // using Key = std::conditional_t, sv, typename T::key_type>; 3410| 1.48M| using Key = typename T::key_type; 3411| 1.48M| if constexpr (std::is_same_v) { 3412| 1.48M| ctx.scratch.clear(); 3413| 1.48M| parse::op(ctx.scratch, ctx, it, end); 3414| 1.48M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3414:26): [True: 0, False: 1.48M] ------------------ 3415| 0| return; 3416| | 3417| 1.48M| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3417:26): [True: 0, False: 1.48M] ------------------ 3418| 0| return; 3419| 0| } 3420| | 3421| 1.48M| reading(ctx.scratch); 3422| | if constexpr (Opts.partial_read) { 3423| | if (read_count == value.size()) { 3424| | return; 3425| | } 3426| | } 3427| 1.48M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 46.0k, False: 1.43M] ------------------ 3428| 46.0k| return; 3429| | } 3430| | else if constexpr (str_t) { 3431| | Key key; 3432| | parse::op(key, ctx, it, end); 3433| | if (bool(ctx.error)) [[unlikely]] 3434| | return; 3435| | 3436| | if (parse_ws_colon(ctx, it, end)) { 3437| | return; 3438| | } 3439| | 3440| | reading(key); 3441| | if constexpr (Opts.partial_read) { 3442| | if (read_count == value.size()) { 3443| | return; 3444| | } 3445| | } 3446| | if (bool(ctx.error)) [[unlikely]] 3447| | return; 3448| | } 3449| | else { 3450| | Key key_value{}; 3451| | if constexpr (is_named_enum || mimics_str_t) { 3452| | parse::op(key_value, ctx, it, end); 3453| | } 3454| | else if constexpr (std::is_arithmetic_v) { 3455| | // prefer over quoted_t below to avoid double parsing of quoted_t 3456| | parse::op>(key_value, ctx, it, end); 3457| | } 3458| | else { 3459| | parse::op>(quoted_t{key_value}, ctx, it, end); 3460| | } 3461| | if (bool(ctx.error)) [[unlikely]] 3462| | return; 3463| | 3464| | if (parse_ws_colon(ctx, it, end)) { 3465| | return; 3466| | } 3467| | 3468| | reading(key_value); 3469| | if constexpr (Opts.partial_read) { 3470| | if (read_count == value.size()) { 3471| | return; 3472| | } 3473| | } 3474| | if (bool(ctx.error)) [[unlikely]] 3475| | return; 3476| | } 3477| 1.48M| } 3478| | 3479| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3480| | if constexpr (has_streaming_state) { 3481| | if (ctx.stream.enabled()) { 3482| | const size_t consumed = static_cast(it - ctx.stream.data()); 3483| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3484| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3485| | const char* new_it; 3486| | const char* new_end; 3487| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3488| | it = new_it; 3489| | end = new_end; 3490| | if (it >= end && ctx.stream.at_eof()) { 3491| | ctx.error = error_code::unexpected_end; 3492| | return; 3493| | } 3494| | } 3495| | } 3496| | } 3497| | 3498| 1.48M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3498:20): [True: 0, False: 1.48M] ------------------ 3499| 0| return; 3500| 0| } 3501| 1.48M| } 3502| 501k| } 3503| 501k| } _ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3148| 501k| decltype(auto) fields = [&]() -> decltype(auto) { 3149| | if constexpr ((glaze_object_t || reflectable) && 3150| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3151| | return bit_array{}; 3152| | } 3153| 501k| else { 3154| 501k| return nullptr; 3155| 501k| } 3156| 501k| }(); _ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlOT_E_clIRNSt3__112basic_stringIcNSS_11char_traitsIcEENSS_9allocatorIcEEEEEEDaSP_: 3394| 1.48M| auto reading = [&](auto&& key) { 3395| | if constexpr (Opts.partial_read) { 3396| | if (auto element = value.find(key); element != value.end()) { 3397| | ++read_count; 3398| | parse::op()>(element->second, ctx, it, end); 3399| | } 3400| | else { 3401| | skip_value::op(ctx, it, end); 3402| | } 3403| | } 3404| 1.48M| else { 3405| 1.48M| parse::op()>(value[key], ctx, it, end); 3406| 1.48M| } 3407| 1.48M| }; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 49| 1.69M| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 1.69M| else { 60| 1.69M| using V = std::remove_cvref_t; 61| 1.69M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.69M| end); 63| 1.69M| } 64| 1.69M| } _ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 150| 1.69M| { 151| 1.69M| using V = std::decay_t(), meta_wrapper_v))>; 152| 1.69M| from::template op(get_member(std::forward(value), meta_wrapper_v), 153| 1.69M| std::forward(ctx), std::forward(it), end); 154| 1.69M| } _ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_: 4065| 1.69M| { 4066| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4067| | read_adjacent(value, ctx, it, end); 4068| | } 4069| 1.69M| else { 4070| 1.69M| read_deduced(value, ctx, it, end); 4071| 1.69M| } 4072| 1.69M| } _ZN3glz4fromILj10ENSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSH_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT0_OT1_OT2_T3_: 4076| 1.69M| { 4077| 1.69M| constexpr auto Opts = ws_handled_off(); 4078| 1.69M| if constexpr (variant_is_auto_deducible()) { 4079| | if constexpr (not check_ws_handled(Options)) { 4080| | if (skip_ws(ctx, it, end)) { 4081| | return; 4082| | } 4083| | } 4084| | 4085| 1.69M| switch (*it) { 4086| 0| case '\0': ------------------ | Branch (4086:13): [True: 0, False: 1.69M] ------------------ 4087| 0| ctx.error = error_code::unexpected_end; 4088| 0| return; 4089| 456k| case '{': { ------------------ | Branch (4089:13): [True: 456k, False: 1.23M] ------------------ 4090| | // This branch consumes the brace itself and hands the object to a reader with 4091| | // `opening_handled`, which therefore does not count the level -- but does release it at 4092| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4093| | // the reader below. 4094| 456k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4094:20): [True: 0, False: 456k] ------------------ 4095| 0| return; 4096| 0| } 4097| | 4098| 456k| ++it; 4099| 456k| if constexpr (not Opts.null_terminated) { 4100| 456k| if (it == end) [[unlikely]] { ------------------ | Branch (4100:23): [True: 0, False: 456k] ------------------ 4101| 0| ctx.error = error_code::unexpected_end; 4102| 0| return; 4103| 0| } 4104| 456k| } 4105| 456k| using type_counts = variant_type_count; 4106| 456k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4107| | if constexpr (n_object_candidates < 1) { 4108| | ctx.error = error_code::no_matching_variant_type; 4109| | return; 4110| | } 4111| 456k| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4112| 456k| constexpr auto first_idx = variant_first_object_candidate_v; 4113| 456k| using V = std::variant_alternative_t; 4114| 456k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4114:23): [True: 456k, False: 0] ------------------ 4115| 456k| parse::op()>(std::get(value), ctx, it, end); 4116| 456k| return; 4117| | } 4118| | else { 4119| | auto possible_types = bit_array>{}.flip(); 4120| | static constexpr auto& deduction_bits = variant_deduction_bits; 4121| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4122| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4123| | 4124| | // Track if we've encountered a tag and what value it had 4125| | std::optional tag_specified_index{}; 4126| | 4127| | if (skip_ws(ctx, it, end)) { 4128| | return; 4129| | } 4130| | // Once the reader knows which alternative this object holds it may have to read 4131| | // it again from here. Anchor the position rather than keep the pointer: the scan 4132| | // below skips values, and a streaming skip refills, which moves the window out 4133| | // from under a raw pointer (see rewind_anchor). 4134| | auto start = make_rewind_anchor(ctx, it); 4135| | bool first_key = true; 4136| | // Parse bifurcation for tagged variants: 4137| | // 4138| | // Without this optimization, tagged variant parsing always uses two passes: 4139| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4140| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4141| | // 4142| | // When the tag is the first key, the second pass redundantly re-reads every 4143| | // field that follows it. This lambda avoids that: if the tag was the first key, 4144| | // it advances past the trailing comma so the object parser picks up at the 4145| | // second field. If the tag was found later, it falls back to the full re-parse. 4146| | // 4147| | // One exception: if the tag name is also a field on the resolved struct 4148| | // (contains_tag), we must re-parse regardless so the value is stored in 4149| | // the struct field. This override is applied inside each std::visit lambda. 4150| | // 4151| | // Either way the rewind can fail under a streaming read: the window only holds so 4152| | // much, and an object wider than it has no start left to return to. 4153| | auto position_after_tag = [&] { 4154| | if (first_key) { 4155| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4156| | return true; 4157| | } 4158| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 4159| | }; 4160| | // `first_key` also answers "were we reset to the object start", which is what 4161| | // position_after_tag does for every key but the first. 4162| | for (; *it != '}'; first_key = false) { 4163| | if (!first_key) { 4164| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4165| | return; 4166| | } 4167| | } 4168| | 4169| | if (skip_ws(ctx, it, end)) { 4170| | return; 4171| | } 4172| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4173| | return; 4174| | } 4175| | 4176| | auto* key_start = it; 4177| | skip_string_view(ctx, it, end); 4178| | if (bool(ctx.error)) [[unlikely]] 4179| | return; 4180| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4181| | return; 4182| | const sv key = {key_start, size_t(it - key_start)}; 4183| | 4184| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4185| | return; 4186| | } 4187| | 4188| | if constexpr (deduction_key_count > 0) { 4189| | // We first check if a tag is defined and see if the key matches the tag 4190| | if constexpr (not tag_v.empty()) { 4191| | if (key == tag_v) { 4192| | if (parse_ws_colon(ctx, it, end)) { 4193| | return; 4194| | } 4195| | 4196| | using id_type = std::decay_t[0])>; 4197| | 4198| | std::conditional_t, id_type, sv> type_id{}; 4199| | if constexpr (std::integral) { 4200| | from::template op()>(type_id, ctx, it, end); 4201| | } 4202| | else { 4203| | // The id is turned into an index below and never leaves this 4204| | // reader, so the view of the window it borrows cannot outlive it. 4205| | parse_transient_string_view()>(type_id, ctx, it, end); 4206| | } 4207| | if (bool(ctx.error)) [[unlikely]] 4208| | return; 4209| | if (skip_ws(ctx, it, end)) { 4210| | return; 4211| | } 4212| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4213| | ctx.error = error_code::syntax_error; 4214| | return; 4215| | } 4216| | 4217| | size_t type_index; 4218| | if constexpr (std::integral) { 4219| | type_index = variant_id_to_index::op(type_id); 4220| | } 4221| | else { 4222| | type_index = variant_id_to_index::op( 4223| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4224| | } 4225| | if (type_index < ids_v.size()) [[likely]] { 4226| | // Check if the deduced types include the tag-specified type 4227| | // If not, the tag doesn't match the fields 4228| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4229| | // is happening. At this point, possible_types has been narrowed by field deduction. 4230| | // Check if the tag-specified type is still possible 4231| | const bool type_is_possible = possible_types[type_index]; 4232| | if (!type_is_possible) { 4233| | // Tag specifies a type that doesn't match the fields seen so far 4234| | ctx.error = error_code::no_matching_variant_type; 4235| | return; 4236| | } 4237| | 4238| | if (!position_after_tag()) return; 4239| | tag_specified_index = type_index; // Store the tag-specified type 4240| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4241| | std::visit( 4242| | [&](auto&& v) { 4243| | using V = std::decay_t; 4244| | constexpr bool is_object = 4245| | (glaze_object_t || reflectable) && not custom_read; 4246| | if constexpr (variant_unit_alternative) { 4247| | // A unit alternative carries no data; its object holds only the 4248| | // discriminator. Consume that body through an empty reflected object so 4249| | // unknown-key policy and terminator handling match every other alternative. 4250| | detail::variant_unit_body unit_body{}; 4251| | from::template op(), 4252| | tag_literal>(unit_body, 4253| | ctx, it, end); 4254| | } 4255| | else if constexpr (is_object) { 4256| | if constexpr (contains_tag()) { 4257| | // tag is a struct field, must re-parse 4258| | if (!start.rewind(ctx, it, end)) return; 4259| | } 4260| | from::template op(), tag_literal>(v, ctx, it, 4261| | end); 4262| | } 4263| | else if constexpr (is_memory_object) { 4264| | if (!v) { 4265| | if constexpr (is_specialization_v) { 4266| | if constexpr (requires { v.emplace(); }) { 4267| | v.emplace(); 4268| | } 4269| | else { 4270| | v = typename V::value_type{}; 4271| | } 4272| | } 4273| | else if constexpr (is_specialization_v) 4274| | v = std::make_unique(); 4275| | else if constexpr (is_specialization_v) 4276| | v = std::make_shared(); 4277| | else if constexpr (constructible) { 4278| | v = meta_construct_v(); 4279| | } 4280| | else if constexpr (std::is_pointer_v && 4281| | can_allocate_raw_pointer>) { 4283| | if (!try_allocate_raw_pointer(v, ctx)) { 4284| | return; 4285| | } 4286| | } 4287| | else { 4288| | ctx.error = error_code::invalid_nullable_read; 4289| | return; 4290| | // Cannot read into unset nullable that is not std::optional, 4291| | // std::unique_ptr, or std::shared_ptr 4292| | } 4293| | } 4294| | if constexpr (contains_tag, tag_literal>()) { 4295| | // tag is a struct field, must re-parse 4296| | if (!start.rewind(ctx, it, end)) return; 4297| | } 4298| | from>::template op(), tag_literal>( 4299| | *v, ctx, it, end); 4300| | } 4301| | else if constexpr (custom_read) { 4302| | // Custom handlers parse the remaining body themselves and do not 4303| | // accept the tag template parameter; the tag was already consumed. 4304| | // This only works when the tag was the first key. If it came later, 4305| | // we were reset to the object start and the custom handler would 4306| | // absorb the tag, so error rather than corrupt the value. 4307| | if (!first_key) { 4308| | ctx.error = error_code::feature_not_supported; 4309| | ctx.custom_error_message = 4310| | "the tag must be the first key for a custom variant alternative"; 4311| | return; 4312| | } 4313| | from::template op()>(v, ctx, it, end); 4314| | } 4315| | }, 4316| | value); 4317| | 4318| | return; // we've decoded our target type 4319| | } 4320| | else [[unlikely]] { 4321| | // Check if we have a default type (ids array shorter than variant) 4322| | constexpr auto ids_size = ids_v.size(); 4323| | constexpr auto variant_size = std::variant_size_v; 4324| | if constexpr (ids_size < variant_size) { 4325| | // Use the first unlabeled type as the default 4326| | const auto default_type_index = ids_size; 4327| | 4328| | if (!position_after_tag()) return; 4329| | tag_specified_index = default_type_index; // Store the default type index 4330| | if (value.index() != default_type_index) 4331| | emplace_runtime_variant(value, default_type_index); 4332| | std::visit( 4333| | [&](auto&& v) { 4334| | using V = std::decay_t; 4335| | constexpr bool is_object = 4336| | (glaze_object_t || reflectable) && not custom_read; 4337| | if constexpr (variant_unit_alternative) { 4338| | // A unit alternative carries no data; its object holds only the 4339| | // discriminator. Consume that body through an empty reflected object so 4340| | // unknown-key policy and terminator handling match every other 4341| | // alternative. 4342| | detail::variant_unit_body unit_body{}; 4343| | from::template op(), 4344| | tag_literal>( 4345| | unit_body, ctx, it, end); 4346| | } 4347| | else if constexpr (is_object) { 4348| | if constexpr (contains_tag()) { 4349| | // tag is a struct field, must re-parse 4350| | if (!start.rewind(ctx, it, end)) return; 4351| | } 4352| | from::template op()>(v, ctx, it, end); 4353| | } 4354| | else if constexpr (is_memory_object) { 4355| | if (!v) { 4356| | if constexpr (is_specialization_v) { 4357| | if constexpr (requires { v.emplace(); }) { 4358| | v.emplace(); 4359| | } 4360| | else { 4361| | v = typename V::value_type{}; 4362| | } 4363| | } 4364| | else if constexpr (is_specialization_v) 4365| | v = std::make_unique(); 4366| | else if constexpr (is_specialization_v) 4367| | v = std::make_shared(); 4368| | else if constexpr (constructible) { 4369| | v = meta_construct_v(); 4370| | } 4371| | else if constexpr (std::is_pointer_v && 4372| | can_allocate_raw_pointer< 4373| | Opts, std::decay_t>) { 4374| | if (!try_allocate_raw_pointer(v, ctx)) { 4375| | return; 4376| | } 4377| | } 4378| | else { 4379| | ctx.error = error_code::invalid_nullable_read; 4380| | return; 4381| | } 4382| | } 4383| | if constexpr (contains_tag, tag_literal>()) { 4384| | // tag is a struct field, must re-parse 4385| | if (!start.rewind(ctx, it, end)) return; 4386| | } 4387| | from>::template op()>(*v, ctx, 4388| | it, end); 4389| | } 4390| | else if constexpr (custom_read) { 4391| | // Custom handlers parse the remaining body themselves; this only 4392| | // works when the tag was the first key (see above). If it came 4393| | // later we were reset to the object start, so error rather than 4394| | // let the custom handler absorb the tag. 4395| | if (!first_key) { 4396| | ctx.error = error_code::feature_not_supported; 4397| | ctx.custom_error_message = 4398| | "the tag must be the first key for a custom variant alternative"; 4399| | return; 4400| | } 4401| | from::template op()>(v, ctx, it, end); 4402| | } 4403| | }, 4404| | value); 4405| | 4406| | return; 4407| | } 4408| | else { 4409| | ctx.error = error_code::no_matching_variant_type; 4410| | ctx.custom_error_message = variant_ids_string_v; 4411| | return; 4412| | } 4413| | } 4414| | } 4415| | } 4416| | 4417| | // Inline decode_hash lookup for variant deduction 4418| | using deduction_keys_t = keys_wrapper>; 4419| | constexpr auto& DeductionHashInfo = hash_info; 4420| | const auto deduction_index = 4421| | decode_hash_with_size::op( 4422| | key.data(), key.data() + key.size(), key.size()); 4423| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4424| | [[likely]] { 4425| | possible_types &= deduction_bits[deduction_index]; 4426| | } 4427| | else if constexpr (Opts.error_on_unknown_keys) { 4428| | ctx.error = error_code::unknown_key; 4429| | return; 4430| | } 4431| | } 4432| | else if constexpr (not tag_v.empty()) { 4433| | // empty object case for variant, if there are no normal elements 4434| | if (key == tag_v) { 4435| | if (parse_ws_colon(ctx, it, end)) { 4436| | return; 4437| | } 4438| | 4439| | // The id is turned into an index below and never leaves this reader, 4440| | // so the view of the window it borrows cannot outlive that window. 4441| | std::string_view type_id{}; 4442| | parse_transient_string_view()>(type_id, ctx, it, end); 4443| | if (bool(ctx.error)) [[unlikely]] 4444| | return; 4445| | if (skip_ws(ctx, it, end)) { 4446| | return; 4447| | } 4448| | 4449| | const auto type_index = variant_id_to_index::op( 4450| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4451| | if (type_index < ids_v.size()) [[likely]] { 4452| | if (!position_after_tag()) return; 4453| | tag_specified_index = type_index; // Store the tag-specified type 4454| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4455| | } 4456| | else { 4457| | // Check if we have a default type (ids array shorter than variant) 4458| | constexpr auto ids_size = ids_v.size(); 4459| | constexpr auto variant_size = std::variant_size_v; 4460| | if constexpr (ids_size < variant_size) { 4461| | // Use the first unlabeled type as the default 4462| | if (!position_after_tag()) return; 4463| | const auto default_index = ids_size; 4464| | tag_specified_index = default_index; // Store the default type index 4465| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4466| | } 4467| | else { 4468| | ctx.error = error_code::no_matching_variant_type; 4469| | ctx.custom_error_message = variant_ids_string_v; 4470| | return; 4471| | } 4472| | } 4473| | // Parse the type (handles tag skipping and unknown keys) 4474| | std::visit( 4475| | [&](auto&& v) { 4476| | using V = std::decay_t; 4477| | if constexpr (custom_read) { 4478| | // Custom handlers parse the remaining object body themselves and do not 4479| | // accept the tag template parameter that reflected objects use to skip an 4480| | // interior tag key. That only works when the tag is the first key (it was 4481| | // just consumed). If the tag came after other keys, position_after_tag() 4482| | // reset us to the object start and the custom handler would absorb the tag 4483| | // into its value, so error here rather than corrupt the result. 4484| | if (!first_key) { 4485| | ctx.error = error_code::feature_not_supported; 4486| | ctx.custom_error_message = 4487| | "the tag must be the first key for a custom variant alternative"; 4488| | return; 4489| | } 4490| | from::template op()>(v, ctx, it, end); 4491| | } 4492| | else { 4493| | if constexpr (contains_tag()) { 4494| | // tag is a struct field, must re-parse 4495| | if (!start.rewind(ctx, it, end)) return; 4496| | } 4497| | from::template op(), tag_literal>(v, ctx, it, end); 4498| | } 4499| | }, 4500| | value); 4501| | return; 4502| | } 4503| | else if constexpr (Opts.error_on_unknown_keys) { 4504| | ctx.error = error_code::unknown_key; 4505| | return; 4506| | } 4507| | else { 4508| | // Skip unknown key's value (non-tag key in empty variant) 4509| | if (parse_ws_colon(ctx, it, end)) { 4510| | return; 4511| | } 4512| | skip_value::op(ctx, it, end); 4513| | if (bool(ctx.error)) [[unlikely]] 4514| | return; 4515| | resync_window_end(ctx, end); // a streaming skip refills 4516| | if (skip_ws(ctx, it, end)) { 4517| | return; 4518| | } 4519| | continue; // Continue loop to find the tag 4520| | } 4521| | } 4522| | else if constexpr (Opts.error_on_unknown_keys) { 4523| | ctx.error = error_code::unknown_key; 4524| | return; 4525| | } 4526| | 4527| | auto matching_types = possible_types.popcount(); 4528| | if (matching_types == 0) { 4529| | ctx.error = error_code::no_matching_variant_type; 4530| | return; 4531| | } 4532| | // Only short-circuit for variants without tags 4533| | else if constexpr (tag_v.empty()) { 4534| | if (matching_types == 1) { 4535| | if (!start.rewind(ctx, it, end)) return; 4536| | const auto type_index = possible_types.countr_zero(); 4537| | 4538| | if (value.index() != static_cast(type_index)) 4539| | emplace_runtime_variant(value, type_index); 4540| | std::visit( 4541| | [&](auto&& v) { 4542| | using V = std::decay_t; 4543| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4544| | if constexpr (variant_unit_alternative) { 4545| | // A unit alternative carries no data; its object holds only the discriminator. 4546| | // Consume that body through an empty reflected object so unknown-key policy and 4547| | // terminator handling match every other alternative. 4548| | detail::variant_unit_body unit_body{}; 4549| | from::template op(), 4550| | tag_literal>(unit_body, ctx, it, 4551| | end); 4552| | } 4553| | else if constexpr (is_object) { 4554| | from::template op(), tag_literal>(v, ctx, it, end); 4555| | } 4556| | else if constexpr (is_memory_object) { 4557| | if (!v) { 4558| | if constexpr (is_specialization_v) { 4559| | if constexpr (requires { v.emplace(); }) { 4560| | v.emplace(); 4561| | } 4562| | else { 4563| | v = typename V::value_type{}; 4564| | } 4565| | } 4566| | else if constexpr (is_specialization_v) 4567| | v = std::make_unique(); 4568| | else if constexpr (is_specialization_v) 4569| | v = std::make_shared(); 4570| | else if constexpr (constructible) { 4571| | v = meta_construct_v(); 4572| | } 4573| | else if constexpr (std::is_pointer_v && 4574| | can_allocate_raw_pointer>) { 4575| | if (!try_allocate_raw_pointer(v, ctx)) { 4576| | return; 4577| | } 4578| | } 4579| | else { 4580| | ctx.error = error_code::invalid_nullable_read; 4581| | return; 4582| | // Cannot read into unset nullable that is not std::optional, 4583| | // std::unique_ptr, or std::shared_ptr 4584| | } 4585| | } 4586| | from>::template op(), tag_literal>( 4587| | *v, ctx, it, end); 4588| | } 4589| | else if constexpr (custom_read) { 4590| | // Custom handlers parse the remaining body themselves. 4591| | from::template op()>(v, ctx, it, end); 4592| | } 4593| | }, 4594| | value); 4595| | 4596| | return; // we've decoded our target type 4597| | } 4598| | } 4599| | // For tagged variants, continue processing to validate tags 4600| | if (parse_ws_colon(ctx, it, end)) { 4601| | return; 4602| | } 4603| | 4604| | skip_value::op(ctx, it, end); 4605| | if (bool(ctx.error)) [[unlikely]] 4606| | return; 4607| | resync_window_end(ctx, end); // a streaming skip refills 4608| | if (skip_ws(ctx, it, end)) { 4609| | return; 4610| | } 4611| | } 4612| | // Only apply ambiguous variant resolution if we have multiple object types 4613| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4614| | // After parsing all keys, check if we have multiple matching types 4615| | // If so, choose the one with the fewest fields 4616| | auto final_matching = possible_types.popcount(); 4617| | if (final_matching == 0) { 4618| | ctx.error = error_code::no_matching_variant_type; 4619| | } 4620| | else if (final_matching == 1) { 4621| | // Single type remains after field deduction 4622| | const auto type_index = possible_types.countr_zero(); 4623| | 4624| | // Validate against tag if one was specified 4625| | if (tag_specified_index.has_value() && 4626| | tag_specified_index.value() != static_cast(type_index)) { 4627| | ctx.error = error_code::no_matching_variant_type; 4628| | return; 4629| | } 4630| | 4631| | if (!start.rewind(ctx, it, end)) return; 4632| | if (value.index() != static_cast(type_index)) 4633| | emplace_runtime_variant(value, type_index); 4634| | std::visit( 4635| | [&](auto&& v) { 4636| | using V = std::decay_t; 4637| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4638| | if constexpr (variant_unit_alternative) { 4639| | // A unit alternative carries no data; its object holds only the discriminator. 4640| | // Consume that body through an empty reflected object so unknown-key policy and 4641| | // terminator handling match every other alternative. 4642| | detail::variant_unit_body unit_body{}; 4643| | from::template op(), 4644| | tag_literal>(unit_body, ctx, it, 4645| | end); 4646| | } 4647| | else if constexpr (is_object) { 4648| | from::template op(), tag_literal>(v, ctx, it, end); 4649| | } 4650| | else if constexpr (is_memory_object) { 4651| | if (!v) { 4652| | if constexpr (is_specialization_v) { 4653| | if constexpr (requires { v.emplace(); }) { 4654| | v.emplace(); 4655| | } 4656| | else { 4657| | v = typename V::value_type{}; 4658| | } 4659| | } 4660| | else if constexpr (is_specialization_v) 4661| | v = std::make_unique(); 4662| | else if constexpr (is_specialization_v) 4663| | v = std::make_shared(); 4664| | else if constexpr (constructible) { 4665| | v = meta_construct_v(); 4666| | } 4667| | else if constexpr (std::is_pointer_v && 4668| | can_allocate_raw_pointer>) { 4669| | if (!try_allocate_raw_pointer(v, ctx)) { 4670| | return; 4671| | } 4672| | } 4673| | else { 4674| | ctx.error = error_code::invalid_nullable_read; 4675| | return; 4676| | } 4677| | } 4678| | from>::template op(), tag_literal>(*v, ctx, 4679| | it, end); 4680| | } 4681| | else if constexpr (custom_read) { 4682| | // Custom handlers parse the remaining body themselves. 4683| | from::template op()>(v, ctx, it, end); 4684| | } 4685| | }, 4686| | value); 4687| | } 4688| | else if (final_matching > 1) { 4689| | constexpr auto N = std::variant_size_v; 4690| | 4691| | // Compile-time array of field counts for each variant type 4692| | constexpr auto field_counts = [](std::index_sequence) { 4693| | return std::array { 4694| | ([]() -> size_t { 4695| | using V = std::decay_t>; 4696| | if constexpr (glaze_object_t || reflectable) { 4697| | return reflect::size; 4698| | } 4699| | else if constexpr (is_memory_object) { 4700| | using X = memory_type; 4701| | if constexpr (glaze_object_t || reflectable) { 4702| | return reflect::size; 4703| | } 4704| | else { 4705| | return (std::numeric_limits::max)(); 4706| | } 4707| | } 4708| | else { 4709| | return (std::numeric_limits::max)(); 4710| | } 4711| | }.template operator()())... 4712| | }; 4713| | }(std::make_index_sequence{}); 4714| | 4715| | // Find the type with minimum field count among the possible types 4716| | size_t min_fields = (std::numeric_limits::max)(); 4717| | size_t chosen_index = N; // Invalid index initially 4718| | 4719| | for (size_t i = 0; i < N; ++i) { 4720| | if (possible_types[i] && field_counts[i] < min_fields) { 4721| | min_fields = field_counts[i]; 4722| | chosen_index = i; 4723| | } 4724| | } 4725| | 4726| | if (chosen_index < N) { 4727| | // Validate against tag if one was specified 4728| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4729| | ctx.error = error_code::no_matching_variant_type; 4730| | return; 4731| | } 4732| | 4733| | if (!start.rewind(ctx, it, end)) return; 4734| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4735| | std::visit( 4736| | [&](auto&& v) { 4737| | using V = std::decay_t; 4738| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4739| | if constexpr (variant_unit_alternative) { 4740| | // A unit alternative carries no data; its object holds only the discriminator. 4741| | // Consume that body through an empty reflected object so unknown-key policy and 4742| | // terminator handling match every other alternative. 4743| | detail::variant_unit_body unit_body{}; 4744| | from::template op(), 4745| | tag_literal>(unit_body, ctx, it, 4746| | end); 4747| | } 4748| | else if constexpr (is_object) { 4749| | from::template op(), tag_literal>(v, ctx, it, end); 4750| | } 4751| | else if constexpr (is_memory_object) { 4752| | if (!v) { 4753| | if constexpr (is_specialization_v) { 4754| | if constexpr (requires { v.emplace(); }) { 4755| | v.emplace(); 4756| | } 4757| | else { 4758| | v = typename V::value_type{}; 4759| | } 4760| | } 4761| | else if constexpr (is_specialization_v) 4762| | v = std::make_unique(); 4763| | else if constexpr (is_specialization_v) 4764| | v = std::make_shared(); 4765| | else if constexpr (constructible) { 4766| | v = meta_construct_v(); 4767| | } 4768| | else if constexpr (std::is_pointer_v && 4769| | can_allocate_raw_pointer>) { 4770| | if (!try_allocate_raw_pointer(v, ctx)) { 4771| | return; 4772| | } 4773| | } 4774| | else { 4775| | ctx.error = error_code::invalid_nullable_read; 4776| | return; 4777| | } 4778| | } 4779| | from>::template op(), tag_literal>( 4780| | *v, ctx, it, end); 4781| | } 4782| | else if constexpr (custom_read) { 4783| | // Custom handlers parse the remaining body themselves. 4784| | from::template op()>(v, ctx, it, end); 4785| | } 4786| | }, 4787| | value); 4788| | } 4789| | else { 4790| | ctx.error = error_code::no_matching_variant_type; 4791| | } 4792| | } 4793| | } 4794| | else { 4795| | // For variants with 0 or 1 object types, use the original error handling 4796| | ctx.error = error_code::no_matching_variant_type; 4797| | } 4798| | } 4799| 0| break; 4800| 456k| } 4801| 175| case '[': ------------------ | Branch (4801:13): [True: 175, False: 1.68M] ------------------ 4802| | // As with '{' above: the array reader each alternative goes through counts the level. 4803| 175| process_variant_alternatives::template op(value, ctx, it, end); 4804| 175| break; 4805| 749k| case '"': { ------------------ | Branch (4805:13): [True: 749k, False: 940k] ------------------ 4806| 749k| process_variant_alternatives::template op(value, ctx, it, end); 4807| 749k| break; 4808| 456k| } 4809| 0| case 't': ------------------ | Branch (4809:13): [True: 0, False: 1.69M] ------------------ 4810| 0| case 'f': { ------------------ | Branch (4810:13): [True: 0, False: 1.69M] ------------------ 4811| 0| process_variant_alternatives::template op(value, ctx, it, end); 4812| 0| break; 4813| 0| } 4814| 217k| case 'n': ------------------ | Branch (4814:13): [True: 217k, False: 1.47M] ------------------ 4815| | if constexpr (variant_count_v == 0) { 4816| | ctx.error = error_code::no_matching_variant_type; 4817| | } 4818| 217k| else { 4819| 217k| constexpr auto first_idx = variant_first_index_v; 4820| 217k| using V = std::variant_alternative_t; 4821| 217k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4821:23): [True: 0, False: 217k] ------------------ 4822| 217k| match<"null", Opts>(ctx, it, end); 4823| 217k| } 4824| 217k| break; 4825| 266k| default: { ------------------ | Branch (4825:13): [True: 266k, False: 1.42M] ------------------ 4826| | // Not bool, string, object, or array so must be number or null 4827| 266k| process_variant_alternatives::template op(value, ctx, it, end); 4828| 266k| } 4829| 1.69M| } 4830| | } 4831| | else { 4832| | // For non-auto-deducible variants, try each type until one succeeds 4833| | constexpr auto N = std::variant_size_v; 4834| | bool parsed = false; 4835| | bool exhausted = false; // speculation budget spent; see charge_speculation 4836| | 4837| | for_each([&]() { 4838| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4839| | 4840| | auto copy_it = it; 4841| | // A rejected alternative may have bailed out inside a container, which leaves its 4842| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4843| | const auto copy_depth = ctx.depth; 4844| | 4845| | // Try parsing as this type 4846| | if (value.index() != I) { 4847| | emplace_runtime_variant(value, I); 4848| | } 4849| | 4850| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4851| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4852| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4853| | } 4854| | 4855| | if (!bool(ctx.error)) { 4856| | parsed = true; 4857| | } 4858| | else if constexpr (not Options.null_terminated) { 4859| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4860| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4861| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4862| | // We advanced the iterator, so we did parse something -- unless what advanced it 4863| | // was an abandoned attempt, which is what a spent speculation budget means. 4864| | parsed = true; 4865| | ctx.error = error_code::none; 4866| | } 4867| | else { 4868| | // Reset for next attempt (unless this is the last type) 4869| | it = copy_it; 4870| | rewind_depth(ctx, copy_depth); 4871| | if constexpr (I + 1 < N) { 4872| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4873| | ctx.error = error_code::none; // Clear error for next attempt 4874| | } 4875| | } 4876| | } 4877| | } 4878| | else { 4879| | // Reset for next attempt (unless this is the last type) 4880| | it = copy_it; 4881| | rewind_depth(ctx, copy_depth); 4882| | if constexpr (I + 1 < N) { 4883| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4884| | ctx.error = error_code::none; // Clear error for next attempt 4885| | } 4886| | } 4887| | } 4888| | }); 4889| | } 4890| 1.69M| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_: 3725| 18.0k| { 3726| 18.0k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 18.0k| else { 3732| 18.0k| constexpr auto N = std::variant_size_v; 3733| 18.0k| constexpr auto const_count = variant_filtered_count_v; 3734| 18.0k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 18.0k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 18.0k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 18.0k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 18.0k| size_t non_const_idx = 0; 3793| | 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 18.0k| return; 3797| 18.0k| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| 18.0k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 18.0k| auto copy_it{it}; 3801| 18.0k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 18.0k| if (!std::holds_alternative(value)) { 3803| 18.0k| value = V{}; 3804| 18.0k| } 3805| 18.0k| parse::op()>(std::get(value), ctx, it, end); 3806| 18.0k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 18.0k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 18.0k| } 3809| 18.0k| if (!bool(ctx.error)) { 3810| 18.0k| found_match = true; 3811| 18.0k| } 3812| 18.0k| else if constexpr (not Options.null_terminated) { 3813| 18.0k| constexpr bool is_complete_type = 3814| 18.0k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 18.0k| if constexpr (is_complete_type) { 3817| 18.0k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 18.0k| found_match = true; 3819| 18.0k| ctx.error = error_code::none; 3820| 18.0k| } 3821| 18.0k| else { 3822| 18.0k| it = copy_it; 3823| 18.0k| rewind_depth(ctx, copy_depth); 3824| 18.0k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 18.0k| not variant_alternative_exhausted(ctx)) { 3826| 18.0k| ctx.error = error_code::none; 3827| 18.0k| } 3828| 18.0k| } 3829| 18.0k| } 3830| 18.0k| else { 3831| 18.0k| it = copy_it; 3832| 18.0k| rewind_depth(ctx, copy_depth); 3833| 18.0k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 18.0k| not variant_alternative_exhausted(ctx)) { 3835| 18.0k| ctx.error = error_code::none; 3836| 18.0k| } 3837| 18.0k| } 3838| 18.0k| } 3839| 18.0k| else { 3840| 18.0k| it = copy_it; 3841| 18.0k| rewind_depth(ctx, copy_depth); 3842| 18.0k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 18.0k| not variant_alternative_exhausted(ctx)) { 3844| 18.0k| ctx.error = error_code::none; 3845| 18.0k| } 3846| 18.0k| } 3847| 18.0k| ++non_const_idx; 3848| 18.0k| } 3849| 18.0k| }); 3850| 18.0k| if (!found_match) { ------------------ | Branch (3850:20): [True: 5.94k, False: 12.1k] ------------------ 3851| 5.94k| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 5.94k| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 18.0k| } 3864| 18.0k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 18.0k] | Branch (3795:38): [True: 0, False: 18.0k] | Branch (3795:51): [True: 0, False: 18.0k] ------------------ 3796| 0| return; 3797| 0| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 18.0k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 18.0k] | Branch (3795:38): [True: 0, False: 18.0k] | Branch (3795:51): [True: 0, False: 18.0k] ------------------ 3796| 0| return; 3797| 0| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 18.0k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 18.0k] | Branch (3795:38): [True: 0, False: 18.0k] | Branch (3795:51): [True: 0, False: 18.0k] ------------------ 3796| 0| return; 3797| 0| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 18.0k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 18.0k] | Branch (3795:38): [True: 0, False: 18.0k] | Branch (3795:51): [True: 0, False: 18.0k] ------------------ 3796| 0| return; 3797| 0| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 18.0k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 18.0k] | Branch (3795:38): [True: 0, False: 18.0k] | Branch (3795:51): [True: 0, False: 18.0k] ------------------ 3796| 0| return; 3797| 0| } 3798| 18.0k| using V = std::variant_alternative_t; 3799| 18.0k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 18.0k| auto copy_it{it}; 3801| 18.0k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 18.0k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 18.0k, False: 0] ------------------ 3803| 18.0k| value = V{}; 3804| 18.0k| } 3805| 18.0k| parse::op()>(std::get(value), ctx, it, end); 3806| 18.0k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 5.94k, False: 12.1k] | Branch (3806:45): [True: 0, False: 5.94k] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 18.0k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 12.1k, False: 5.94k] ------------------ 3810| 12.1k| found_match = true; 3811| 12.1k| } 3812| 5.94k| else if constexpr (not Options.null_terminated) { 3813| 5.94k| constexpr bool is_complete_type = 3814| 5.94k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [Folded, False: 0] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [Folded, False: 0] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| 5.94k| else { 3831| 5.94k| it = copy_it; 3832| 5.94k| rewind_depth(ctx, copy_depth); 3833| 5.94k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3833:32): [True: 0, False: 5.94k] | Branch (3833:71): [True: 0, False: 0] ------------------ 3834| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3834:32): [True: 0, False: 0] ------------------ 3835| 0| ctx.error = error_code::none; 3836| 0| } 3837| 5.94k| } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 18.0k| ++non_const_idx; 3848| 18.0k| } 3849| 18.0k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS4_9allocatorIS9_EEEETkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_: 49| 18.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 18.0k| else { 60| 18.0k| using V = std::remove_cvref_t; 61| 18.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 18.0k| end); 63| 18.0k| } 64| 18.0k| } _ZN3glz4fromILj10ENSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS1_9allocatorIS6_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS9_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_: 2308| 18.0k| { 2309| 18.0k| constexpr auto Opts = ws_handled_off(); 2310| | if constexpr (!check_ws_handled(Options)) { 2311| | if (skip_ws(ctx, it, end)) { 2312| | return; 2313| | } 2314| | } 2315| | 2316| 18.0k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2316:14): [True: 0, False: 18.0k] ------------------ 2317| 0| return; 2318| 0| } 2319| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2320| | // released at each syntactic close below 2321| 18.0k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2321:14): [True: 0, False: 18.0k] ------------------ 2322| 0| return; 2323| 0| } 2324| | 2325| 18.0k| const auto ws_start = it; 2326| 18.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2326:14): [True: 0, False: 18.0k] ------------------ 2327| 0| return; 2328| 0| } 2329| | 2330| 18.0k| if (*it == ']') { ------------------ | Branch (2330:14): [True: 175, False: 17.8k] ------------------ 2331| 175| --ctx.depth; 2332| 175| ++it; 2333| 175| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2334| 175| value.clear(); 2335| | 2336| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2337| | value.shrink_to_fit(); 2338| | } 2339| 175| } 2340| 175| return; 2341| 175| } 2342| | 2343| 17.8k| const size_t ws_size = size_t(it - ws_start); 2344| | 2345| 17.8k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2345:49): [True: 17.8k, Folded] | Branch (2345:65): [Folded, False: 0] | Branch (2345:90): [Folded, False: 0] ------------------ 2346| 17.8k| if constexpr (not should_append) { 2347| 17.8k| const auto n = value.size(); 2348| | 2349| 17.8k| auto value_it = value.begin(); 2350| | 2351| 17.8k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2351:32): [True: 0, False: 17.8k] ------------------ 2352| 0| parse::op()>(*value_it++, ctx, it, end); 2353| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2353:20): [True: 0, False: 0] ------------------ 2354| 0| return; 2355| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2355:20): [True: 0, False: 0] ------------------ 2356| 0| return; 2357| 0| } 2358| 0| if (*it == ',') { ------------------ | Branch (2358:20): [True: 0, False: 0] ------------------ 2359| 0| ++it; 2360| | 2361| 0| if constexpr (!Opts.minified && !Opts.comments) { 2362| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2362:26): [True: 0, False: 0] | Branch (2362:37): [True: 0, False: 0] ------------------ 2363| 0| skip_matching_ws(ws_start, it, ws_size); 2364| 0| } 2365| 0| } 2366| | 2367| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:23): [True: 0, False: 0] ------------------ 2368| 0| return; 2369| 0| } 2370| 0| } 2371| 0| else if (*it == ']') { ------------------ | Branch (2371:25): [True: 0, False: 0] ------------------ 2372| 0| --ctx.depth; 2373| 0| ++it; 2374| 0| if constexpr (erasable) { 2375| 0| value.erase(value_it, 2376| 0| value.end()); // use erase rather than resize for non-default constructible elements 2377| | 2378| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2379| | value.shrink_to_fit(); 2380| | } 2381| 0| } 2382| 0| return; 2383| 0| } 2384| 0| else [[unlikely]] { 2385| 0| ctx.error = error_code::expected_bracket; 2386| 0| return; 2387| 0| } 2388| 0| } 2389| 17.8k| } 2390| | 2391| | if constexpr (Opts.partial_read) { 2392| | // partial_read stops early on a success path, so give the level back like the 2393| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2394| | --ctx.depth; 2395| | return; 2396| | } 2397| 17.8k| else { 2398| | // growing 2399| 17.8k| if constexpr (emplace_backable || has_try_emplace_back) { 2400| 209k| while (it < end) { ------------------ | Branch (2400:23): [True: 209k, False: 0] ------------------ 2401| | // Streaming refill point: at start of each iteration, ensure buffer has data 2402| | if constexpr (has_streaming_state) { 2403| | if (ctx.stream.enabled()) { 2404| | const size_t consumed = static_cast(it - ctx.stream.data()); 2405| | const size_t remaining = ctx.stream.size() - consumed; 2406| | // Refill when less than half of buffer remains to ensure space for next element 2407| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2408| | const char* new_it; 2409| | const char* new_end; 2410| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2411| | it = new_it; 2412| | end = new_end; 2413| | if (it >= end && ctx.stream.at_eof()) { 2414| | break; // No more data, exit loop normally 2415| | } 2416| | } 2417| | } 2418| | } 2419| | 2420| | if constexpr (has_try_emplace_back) { 2421| | if (value.try_emplace_back()) 2422| | parse::op()>(value.back(), ctx, it, end); 2423| | else 2424| | ctx.error = error_code::exceeded_static_array_size; 2425| | } 2426| 209k| else { 2427| 209k| parse::op()>(value.emplace_back(), ctx, it, end); 2428| 209k| } 2429| | 2430| 209k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2430:23): [True: 5.94k, False: 203k] ------------------ 2431| 5.94k| return; 2432| | 2433| | // Streaming refill point: after parsing each element, refill if buffer is low 2434| | if constexpr (has_streaming_state) { 2435| | if (ctx.stream.enabled()) { 2436| | const size_t consumed = static_cast(it - ctx.stream.data()); 2437| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2438| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2439| | const char* new_it; 2440| | const char* new_end; 2441| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2442| | it = new_it; 2443| | end = new_end; 2444| | if (it >= end && ctx.stream.at_eof()) { 2445| | ctx.error = error_code::unexpected_end; 2446| | return; 2447| | } 2448| | } 2449| | } 2450| | } 2451| | 2452| 203k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2452:23): [True: 0, False: 203k] ------------------ 2453| 0| return; 2454| 0| } 2455| 203k| if (*it == ',') [[likely]] { ------------------ | Branch (2455:23): [True: 191k, False: 11.9k] ------------------ 2456| 191k| ++it; 2457| | 2458| 191k| if constexpr (!Opts.minified && !Opts.comments) { 2459| 191k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2459:29): [True: 0, False: 191k] | Branch (2459:40): [True: 0, False: 0] ------------------ 2460| 0| skip_matching_ws(ws_start, it, ws_size); 2461| 0| } 2462| 191k| } 2463| | 2464| 191k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2464:26): [True: 0, False: 191k] ------------------ 2465| 0| return; 2466| 0| } 2467| 191k| } 2468| 11.9k| else if (*it == ']') { ------------------ | Branch (2468:28): [True: 11.9k, False: 0] ------------------ 2469| 11.9k| --ctx.depth; 2470| 11.9k| ++it; 2471| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2472| | value.shrink_to_fit(); 2473| | } 2474| 11.9k| return; 2475| 11.9k| } 2476| 0| else [[unlikely]] { 2477| 0| ctx.error = error_code::expected_bracket; 2478| 0| return; 2479| 0| } 2480| 203k| } 2481| | 2482| | // A valid array always returns from inside the loop upon reaching ']'. 2483| | // For a null-terminated buffer the loop can only exit here by falling 2484| | // through when `it` reaches the terminator without a closing bracket, 2485| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2486| | // Non-null-terminated buffers surface this through skip_ws/depth 2487| | // tracking (or the streaming refill break), so this guard is limited 2488| | // to the null-terminated case. 2489| | if constexpr (Opts.null_terminated) { 2490| | ctx.error = error_code::unexpected_end; 2491| | } 2492| | } 2493| | else { 2494| | ctx.error = error_code::exceeded_static_array_size; 2495| | } 2496| 17.8k| } 2497| 17.8k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav: 3794| 18.0k| for_each([&]() { 3795| 18.0k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 12.1k, False: 5.94k] | Branch (3795:38): [True: 0, False: 5.94k] | Branch (3795:51): [True: 0, False: 5.94k] ------------------ 3796| 12.1k| return; 3797| 12.1k| } 3798| 5.94k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 5.94k| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_: 3725| 749k| { 3726| 749k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 749k| else { 3732| 749k| constexpr auto N = std::variant_size_v; 3733| 749k| constexpr auto const_count = variant_filtered_count_v; 3734| 749k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 749k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 749k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 749k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 749k| size_t non_const_idx = 0; 3793| | 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 749k| return; 3797| 749k| } 3798| 749k| using V = std::variant_alternative_t; 3799| 749k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 749k| auto copy_it{it}; 3801| 749k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 749k| if (!std::holds_alternative(value)) { 3803| 749k| value = V{}; 3804| 749k| } 3805| 749k| parse::op()>(std::get(value), ctx, it, end); 3806| 749k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 749k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 749k| } 3809| 749k| if (!bool(ctx.error)) { 3810| 749k| found_match = true; 3811| 749k| } 3812| 749k| else if constexpr (not Options.null_terminated) { 3813| 749k| constexpr bool is_complete_type = 3814| 749k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 749k| if constexpr (is_complete_type) { 3817| 749k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 749k| found_match = true; 3819| 749k| ctx.error = error_code::none; 3820| 749k| } 3821| 749k| else { 3822| 749k| it = copy_it; 3823| 749k| rewind_depth(ctx, copy_depth); 3824| 749k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 749k| not variant_alternative_exhausted(ctx)) { 3826| 749k| ctx.error = error_code::none; 3827| 749k| } 3828| 749k| } 3829| 749k| } 3830| 749k| else { 3831| 749k| it = copy_it; 3832| 749k| rewind_depth(ctx, copy_depth); 3833| 749k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 749k| not variant_alternative_exhausted(ctx)) { 3835| 749k| ctx.error = error_code::none; 3836| 749k| } 3837| 749k| } 3838| 749k| } 3839| 749k| else { 3840| 749k| it = copy_it; 3841| 749k| rewind_depth(ctx, copy_depth); 3842| 749k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 749k| not variant_alternative_exhausted(ctx)) { 3844| 749k| ctx.error = error_code::none; 3845| 749k| } 3846| 749k| } 3847| 749k| ++non_const_idx; 3848| 749k| } 3849| 749k| }); 3850| 749k| if (!found_match) { ------------------ | Branch (3850:20): [True: 23.2k, False: 726k] ------------------ 3851| 23.2k| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 23.2k| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 749k| } 3864| 749k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 749k] | Branch (3795:38): [True: 0, False: 749k] | Branch (3795:51): [True: 0, False: 749k] ------------------ 3796| 0| return; 3797| 0| } 3798| 749k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 749k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 749k] | Branch (3795:38): [True: 0, False: 749k] | Branch (3795:51): [True: 0, False: 749k] ------------------ 3796| 0| return; 3797| 0| } 3798| 749k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 749k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 749k] | Branch (3795:38): [True: 0, False: 749k] | Branch (3795:51): [True: 0, False: 749k] ------------------ 3796| 0| return; 3797| 0| } 3798| 749k| using V = std::variant_alternative_t; 3799| 749k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 749k| auto copy_it{it}; 3801| 749k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 749k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 749k, False: 0] ------------------ 3803| 749k| value = V{}; 3804| 749k| } 3805| 749k| parse::op()>(std::get(value), ctx, it, end); 3806| 749k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 23.2k, False: 726k] | Branch (3806:45): [True: 0, False: 23.2k] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 749k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 726k, False: 23.2k] ------------------ 3810| 726k| found_match = true; 3811| 726k| } 3812| 23.2k| else if constexpr (not Options.null_terminated) { 3813| 23.2k| constexpr bool is_complete_type = 3814| 23.2k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [Folded, False: 0] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [True: 0, Folded] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| 23.2k| if constexpr (is_complete_type) { 3817| 23.2k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3817:32): [True: 0, False: 23.2k] | Branch (3817:72): [True: 0, False: 0] | Branch (3817:88): [True: 0, False: 0] ------------------ 3818| 0| found_match = true; 3819| 0| ctx.error = error_code::none; 3820| 0| } 3821| 23.2k| else { 3822| 23.2k| it = copy_it; 3823| 23.2k| rewind_depth(ctx, copy_depth); 3824| 23.2k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3824:35): [True: 0, False: 23.2k] | Branch (3824:74): [True: 0, False: 0] ------------------ 3825| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3825:35): [True: 0, False: 0] ------------------ 3826| 0| ctx.error = error_code::none; 3827| 0| } 3828| 23.2k| } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 749k| ++non_const_idx; 3848| 749k| } 3849| 749k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 726k, False: 23.2k] | Branch (3795:38): [True: 0, False: 23.2k] | Branch (3795:51): [True: 0, False: 23.2k] ------------------ 3796| 726k| return; 3797| 726k| } 3798| 23.2k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 23.2k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 726k, False: 23.2k] | Branch (3795:38): [True: 0, False: 23.2k] | Branch (3795:51): [True: 0, False: 23.2k] ------------------ 3796| 726k| return; 3797| 726k| } 3798| 23.2k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 23.2k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav: 3794| 749k| for_each([&]() { 3795| 749k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 726k, False: 23.2k] | Branch (3795:38): [True: 0, False: 23.2k] | Branch (3795:51): [True: 0, False: 23.2k] ------------------ 3796| 726k| return; 3797| 726k| } 3798| 23.2k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 23.2k| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_: 3725| 266k| { 3726| 266k| constexpr auto category_count = variant_count_v; 3727| | 3728| | if constexpr (category_count == 0) { 3729| | ctx.error = error_code::no_matching_variant_type; 3730| | } 3731| 266k| else { 3732| 266k| constexpr auto N = std::variant_size_v; 3733| 266k| constexpr auto const_count = variant_filtered_count_v; 3734| 266k| constexpr auto non_const_count = variant_filtered_count_v; 3735| | 3736| 266k| bool found_match{}; 3737| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3738| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3739| | // so the budget stops it and the failure already in hand is reported. 3740| 266k| bool exhausted{}; 3741| | 3742| | // First pass: const glaze types in this category 3743| | if constexpr (const_count > 0) { 3744| | for_each([&]() { 3745| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3746| | return; 3747| | } 3748| | using V = std::variant_alternative_t; 3749| | if constexpr (Trait::value && glaze_const_value_t) { 3750| | // run time substitute to compare to const value 3751| | std::remove_const_t>>> substitute{}; 3752| | auto copy_it{it}; 3753| | // A rejected alternative may have bailed out inside a container, which leaves its 3754| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3755| | // trying N alternatives cannot spend N levels of the recursion budget. 3756| | const auto copy_depth{ctx.depth}; 3757| | parse::op()>(substitute, ctx, it, end); 3758| | static constexpr auto const_value{*meta_wrapper_v}; 3759| | if (substitute == const_value) { 3760| | found_match = true; 3761| | if (!std::holds_alternative(value)) { 3762| | value = V{}; 3763| | } 3764| | } 3765| | else { 3766| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3767| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3768| | exhausted = true; 3769| | } 3770| | if constexpr (not Options.null_terminated) { 3771| | if (ctx.error == error_code::end_reached && not exhausted) { 3772| | ctx.error = error_code::none; 3773| | } 3774| | } 3775| | it = copy_it; 3776| | rewind_depth(ctx, copy_depth); 3777| | } 3778| | } 3779| | }); 3780| | if (found_match) { 3781| | return; 3782| | } 3783| | } 3784| | 3785| | // Second pass: non-const types in this category 3786| 266k| if constexpr (non_const_count > 0) { 3787| | // Track position within matching types for "is last" check. 3788| | // We iterate over all variant indices but only process matching types, 3789| | // so we need runtime tracking (vs the old tuple-based approach where 3790| | // the loop index directly corresponded to position in filtered set). 3791| | // This has negligible cost: one increment per matching type. 3792| 266k| size_t non_const_idx = 0; 3793| | 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3796| 266k| return; 3797| 266k| } 3798| 266k| using V = std::variant_alternative_t; 3799| 266k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 266k| auto copy_it{it}; 3801| 266k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 266k| if (!std::holds_alternative(value)) { 3803| 266k| value = V{}; 3804| 266k| } 3805| 266k| parse::op()>(std::get(value), ctx, it, end); 3806| 266k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| 266k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 266k| } 3809| 266k| if (!bool(ctx.error)) { 3810| 266k| found_match = true; 3811| 266k| } 3812| 266k| else if constexpr (not Options.null_terminated) { 3813| 266k| constexpr bool is_complete_type = 3814| 266k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| 266k| if constexpr (is_complete_type) { 3817| 266k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| 266k| found_match = true; 3819| 266k| ctx.error = error_code::none; 3820| 266k| } 3821| 266k| else { 3822| 266k| it = copy_it; 3823| 266k| rewind_depth(ctx, copy_depth); 3824| 266k| if (non_const_idx + 1 < non_const_count && not exhausted && 3825| 266k| not variant_alternative_exhausted(ctx)) { 3826| 266k| ctx.error = error_code::none; 3827| 266k| } 3828| 266k| } 3829| 266k| } 3830| 266k| else { 3831| 266k| it = copy_it; 3832| 266k| rewind_depth(ctx, copy_depth); 3833| 266k| if (non_const_idx + 1 < non_const_count && not exhausted && 3834| 266k| not variant_alternative_exhausted(ctx)) { 3835| 266k| ctx.error = error_code::none; 3836| 266k| } 3837| 266k| } 3838| 266k| } 3839| 266k| else { 3840| 266k| it = copy_it; 3841| 266k| rewind_depth(ctx, copy_depth); 3842| 266k| if (non_const_idx + 1 < non_const_count && not exhausted && 3843| 266k| not variant_alternative_exhausted(ctx)) { 3844| 266k| ctx.error = error_code::none; 3845| 266k| } 3846| 266k| } 3847| 266k| ++non_const_idx; 3848| 266k| } 3849| 266k| }); 3850| 266k| if (!found_match) { ------------------ | Branch (3850:20): [True: 0, False: 266k] ------------------ 3851| 0| if constexpr (non_const_count == 1) { 3852| | // Keep the specific error from the single type we tried 3853| | } 3854| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3855| | // Over-nested input is not a failure of the alternative set; keep saying so. 3856| | ctx.error = error_code::no_matching_variant_type; 3857| | } 3858| 0| } 3859| | } 3860| | else { 3861| | ctx.error = error_code::no_matching_variant_type; 3862| | } 3863| 266k| } 3864| 266k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 266k] | Branch (3795:38): [True: 0, False: 266k] | Branch (3795:51): [True: 0, False: 266k] ------------------ 3796| 0| return; 3797| 0| } 3798| 266k| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 266k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 0, False: 266k] | Branch (3795:38): [True: 0, False: 266k] | Branch (3795:51): [True: 0, False: 266k] ------------------ 3796| 0| return; 3797| 0| } 3798| 266k| using V = std::variant_alternative_t; 3799| 266k| if constexpr (Trait::value && !glaze_const_value_t) { 3800| 266k| auto copy_it{it}; 3801| 266k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| 266k| if (!std::holds_alternative(value)) { ------------------ | Branch (3802:26): [True: 266k, False: 0] ------------------ 3803| 266k| value = V{}; 3804| 266k| } 3805| 266k| parse::op()>(std::get(value), ctx, it, end); 3806| 266k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3806:26): [True: 0, False: 266k] | Branch (3806:45): [True: 0, False: 0] ------------------ 3807| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| 0| } 3809| 266k| if (!bool(ctx.error)) { ------------------ | Branch (3809:26): [True: 266k, False: 0] ------------------ 3810| 266k| found_match = true; 3811| 266k| } 3812| 0| else if constexpr (not Options.null_terminated) { 3813| 0| constexpr bool is_complete_type = 3814| 0| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3814:28): [True: 0, Folded] | Branch (3814:40): [Folded, False: 0] | Branch (3814:53): [Folded, False: 0] | Branch (3814:68): [Folded, False: 0] | Branch (3814:89): [Folded, False: 0] | Branch (3814:103): [Folded, False: 0] ------------------ 3815| | 3816| 0| if constexpr (is_complete_type) { 3817| 0| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3817:32): [True: 0, False: 0] | Branch (3817:72): [True: 0, False: 0] | Branch (3817:88): [True: 0, False: 0] ------------------ 3818| 0| found_match = true; 3819| 0| ctx.error = error_code::none; 3820| 0| } 3821| 0| else { 3822| 0| it = copy_it; 3823| 0| rewind_depth(ctx, copy_depth); 3824| 0| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3824:35): [True: 0, False: 0] | Branch (3824:74): [True: 0, False: 0] ------------------ 3825| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3825:35): [True: 0, False: 0] ------------------ 3826| 0| ctx.error = error_code::none; 3827| 0| } 3828| 0| } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| 266k| ++non_const_idx; 3848| 266k| } 3849| 266k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 266k, False: 0] | Branch (3795:38): [True: 0, False: 0] | Branch (3795:51): [True: 0, False: 0] ------------------ 3796| 266k| return; 3797| 266k| } 3798| 0| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 0| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm3EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 266k, False: 0] | Branch (3795:38): [True: 0, False: 0] | Branch (3795:51): [True: 0, False: 0] ------------------ 3796| 266k| return; 3797| 266k| } 3798| 0| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 0| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm4EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 266k, False: 0] | Branch (3795:38): [True: 0, False: 0] | Branch (3795:51): [True: 0, False: 0] ------------------ 3796| 266k| return; 3797| 266k| } 3798| 0| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 0| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDndNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbNS1_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS6_ISD_EEEENSC_ISD_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSH_TkNS_10is_contextERNS_7contextERPKcSQ_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm5EEEDav: 3794| 266k| for_each([&]() { 3795| 266k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3795:23): [True: 266k, False: 0] | Branch (3795:38): [True: 0, False: 0] | Branch (3795:51): [True: 0, False: 0] ------------------ 3796| 266k| return; 3797| 266k| } 3798| 0| using V = std::variant_alternative_t; 3799| | if constexpr (Trait::value && !glaze_const_value_t) { 3800| | auto copy_it{it}; 3801| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3802| | if (!std::holds_alternative(value)) { 3803| | value = V{}; 3804| | } 3805| | parse::op()>(std::get(value), ctx, it, end); 3806| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3807| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3808| | } 3809| | if (!bool(ctx.error)) { 3810| | found_match = true; 3811| | } 3812| | else if constexpr (not Options.null_terminated) { 3813| | constexpr bool is_complete_type = 3814| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3815| | 3816| | if constexpr (is_complete_type) { 3817| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3818| | found_match = true; 3819| | ctx.error = error_code::none; 3820| | } 3821| | else { 3822| | it = copy_it; 3823| | rewind_depth(ctx, copy_depth); 3824| | if (non_const_idx + 1 < non_const_count && not exhausted && 3825| | not variant_alternative_exhausted(ctx)) { 3826| | ctx.error = error_code::none; 3827| | } 3828| | } 3829| | } 3830| | else { 3831| | it = copy_it; 3832| | rewind_depth(ctx, copy_depth); 3833| | if (non_const_idx + 1 < non_const_count && not exhausted && 3834| | not variant_alternative_exhausted(ctx)) { 3835| | ctx.error = error_code::none; 3836| | } 3837| | } 3838| | } 3839| | else { 3840| | it = copy_it; 3841| | rewind_depth(ctx, copy_depth); 3842| | if (non_const_idx + 1 < non_const_count && not exhausted && 3843| | not variant_alternative_exhausted(ctx)) { 3844| | ctx.error = error_code::none; 3845| | } 3846| | } 3847| | ++non_const_idx; 3848| | } 3849| 0| }); _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_: 321| 16.8k| { 322| 16.8k| using namespace glz::detail; 323| | 324| | // Validating skips (parse_value/JSON pointer) require the full value in a 325| | // contiguous buffer, so streaming refill is not applied there. 326| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 327| | if (ctx.stream.enabled()) { 328| | skip_value_streaming(ctx, it, end); 329| | return; 330| | } 331| | } 332| | 333| 16.8k| if constexpr (not check_validate_skipped(Opts)) { 334| 16.8k| if constexpr (not check_ws_handled(Opts)) { 335| 16.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (335:17): [True: 0, False: 16.8k] ------------------ 336| 0| return; 337| 0| } 338| 16.8k| } 339| 52.4k| while (true) { ------------------ | Branch (339:17): [True: 52.4k, Folded] ------------------ 340| 52.4k| switch (*it) { 341| 1.46k| case '{': ------------------ | Branch (341:13): [True: 1.46k, False: 51.0k] ------------------ 342| 1.46k| ++it; 343| 1.46k| if constexpr (not Opts.null_terminated) { 344| 1.46k| if (it == end) [[unlikely]] { ------------------ | Branch (344:23): [True: 0, False: 1.46k] ------------------ 345| 0| ctx.error = error_code::unexpected_end; 346| 0| return; 347| 0| } 348| 1.46k| } 349| 1.46k| skip_until_closed(ctx, it, end); 350| 1.46k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (350:20): [True: 0, False: 1.46k] ------------------ 351| 0| return; 352| 1.46k| break; 353| 4.72k| case '[': ------------------ | Branch (353:13): [True: 4.72k, False: 47.7k] ------------------ 354| 4.72k| ++it; 355| 4.72k| if constexpr (not Opts.null_terminated) { 356| 4.72k| if (it == end) [[unlikely]] { ------------------ | Branch (356:23): [True: 0, False: 4.72k] ------------------ 357| 0| ctx.error = error_code::unexpected_end; 358| 0| return; 359| 0| } 360| 4.72k| } 361| 4.72k| skip_until_closed(ctx, it, end); 362| 4.72k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (362:20): [True: 0, False: 4.72k] ------------------ 363| 0| return; 364| 4.72k| break; 365| 5.57k| case '"': ------------------ | Branch (365:13): [True: 5.57k, False: 46.9k] ------------------ 366| 5.57k| skip_string(ctx, it, end); 367| 5.57k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (367:20): [True: 0, False: 5.57k] ------------------ 368| 0| return; 369| 5.57k| break; 370| 5.57k| case ',': ------------------ | Branch (370:13): [True: 4.69k, False: 47.8k] ------------------ 371| 5.04k| case '}': ------------------ | Branch (371:13): [True: 350, False: 52.1k] ------------------ 372| 5.04k| case ']': ------------------ | Branch (372:13): [True: 0, False: 52.4k] ------------------ 373| 5.04k| break; 374| 0| case '\0': ------------------ | Branch (374:13): [True: 0, False: 52.4k] ------------------ 375| 0| ctx.error = error_code::unexpected_end; 376| 0| return; 377| 35.6k| default: { ------------------ | Branch (377:13): [True: 35.6k, False: 16.8k] ------------------ 378| 35.6k| ++it; 379| 35.6k| if constexpr (not Opts.null_terminated) { 380| 35.6k| if (it == end) [[unlikely]] { ------------------ | Branch (380:23): [True: 0, False: 35.6k] ------------------ 381| 0| ctx.error = error_code::unexpected_end; 382| 0| return; 383| 0| } 384| 35.6k| } 385| 35.6k| continue; 386| 5.04k| } 387| 52.4k| } 388| | 389| 16.8k| break; 390| 52.4k| } 391| | } 392| | else { 393| | if constexpr (not check_ws_handled(Opts)) { 394| | if (skip_ws(ctx, it, end)) { 395| | return; 396| | } 397| | } 398| | switch (*it) { 399| | case '{': { 400| | skip_object(ctx, it, end); 401| | break; 402| | } 403| | case '[': { 404| | skip_array(ctx, it, end); 405| | break; 406| | } 407| | case '"': { 408| | skip_string(ctx, it, end); 409| | break; 410| | } 411| | case 'n': { 412| | ++it; 413| | match<"ull", Opts>(ctx, it, end); 414| | break; 415| | } 416| | case 'f': { 417| | ++it; 418| | match<"alse", Opts>(ctx, it, end); 419| | break; 420| | } 421| | case 't': { 422| | ++it; 423| | match<"rue", Opts>(ctx, it, end); 424| | break; 425| | } 426| | case '\0': { 427| | ctx.error = error_code::unexpected_end; 428| | break; 429| | } 430| | default: { 431| | skip_number(ctx, it, end); 432| | } 433| | } 434| | } 435| 16.8k| } _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_: 321| 5.16M| { 322| 5.16M| using namespace glz::detail; 323| | 324| | // Validating skips (parse_value/JSON pointer) require the full value in a 325| | // contiguous buffer, so streaming refill is not applied there. 326| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 327| | if (ctx.stream.enabled()) { 328| | skip_value_streaming(ctx, it, end); 329| | return; 330| | } 331| | } 332| | 333| 5.16M| if constexpr (not check_validate_skipped(Opts)) { 334| | if constexpr (not check_ws_handled(Opts)) { 335| | if (skip_ws(ctx, it, end)) { 336| | return; 337| | } 338| | } 339| 19.1M| while (true) { ------------------ | Branch (339:17): [True: 19.1M, Folded] ------------------ 340| 19.1M| switch (*it) { 341| 150k| case '{': ------------------ | Branch (341:13): [True: 150k, False: 18.9M] ------------------ 342| 150k| ++it; 343| 150k| if constexpr (not Opts.null_terminated) { 344| 150k| if (it == end) [[unlikely]] { ------------------ | Branch (344:23): [True: 4, False: 150k] ------------------ 345| 4| ctx.error = error_code::unexpected_end; 346| 4| return; 347| 4| } 348| 150k| } 349| 150k| skip_until_closed(ctx, it, end); 350| 150k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (350:20): [True: 2.63k, False: 147k] ------------------ 351| 2.63k| return; 352| 147k| break; 353| 147k| case '[': ------------------ | Branch (353:13): [True: 12.7k, False: 19.1M] ------------------ 354| 12.7k| ++it; 355| 12.7k| if constexpr (not Opts.null_terminated) { 356| 12.7k| if (it == end) [[unlikely]] { ------------------ | Branch (356:23): [True: 7, False: 12.7k] ------------------ 357| 7| ctx.error = error_code::unexpected_end; 358| 7| return; 359| 7| } 360| 12.7k| } 361| 12.7k| skip_until_closed(ctx, it, end); 362| 12.7k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (362:20): [True: 2.67k, False: 10.0k] ------------------ 363| 2.67k| return; 364| 10.0k| break; 365| 14.3k| case '"': ------------------ | Branch (365:13): [True: 14.3k, False: 19.1M] ------------------ 366| 14.3k| skip_string(ctx, it, end); 367| 14.3k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (367:20): [True: 287, False: 14.1k] ------------------ 368| 287| return; 369| 14.1k| break; 370| 4.98M| case ',': ------------------ | Branch (370:13): [True: 4.98M, False: 14.1M] ------------------ 371| 4.98M| case '}': ------------------ | Branch (371:13): [True: 1.95k, False: 19.1M] ------------------ 372| 4.98M| case ']': ------------------ | Branch (372:13): [True: 727, False: 19.1M] ------------------ 373| 4.98M| break; 374| 624| case '\0': ------------------ | Branch (374:13): [True: 624, False: 19.1M] ------------------ 375| 624| ctx.error = error_code::unexpected_end; 376| 624| return; 377| 13.9M| default: { ------------------ | Branch (377:13): [True: 13.9M, False: 5.16M] ------------------ 378| 13.9M| ++it; 379| 13.9M| if constexpr (not Opts.null_terminated) { 380| 13.9M| if (it == end) [[unlikely]] { ------------------ | Branch (380:23): [True: 152, False: 13.9M] ------------------ 381| 152| ctx.error = error_code::unexpected_end; 382| 152| return; 383| 152| } 384| 13.9M| } 385| 13.9M| continue; 386| 4.98M| } 387| 19.1M| } 388| | 389| 5.16M| break; 390| 19.1M| } 391| | } 392| | else { 393| | if constexpr (not check_ws_handled(Opts)) { 394| | if (skip_ws(ctx, it, end)) { 395| | return; 396| | } 397| | } 398| | switch (*it) { 399| | case '{': { 400| | skip_object(ctx, it, end); 401| | break; 402| | } 403| | case '[': { 404| | skip_array(ctx, it, end); 405| | break; 406| | } 407| | case '"': { 408| | skip_string(ctx, it, end); 409| | break; 410| | } 411| | case 'n': { 412| | ++it; 413| | match<"ull", Opts>(ctx, it, end); 414| | break; 415| | } 416| | case 'f': { 417| | ++it; 418| | match<"alse", Opts>(ctx, it, end); 419| | break; 420| | } 421| | case 't': { 422| | ++it; 423| | match<"rue", Opts>(ctx, it, end); 424| | break; 425| | } 426| | case '\0': { 427| | ctx.error = error_code::unexpected_end; 428| | break; 429| | } 430| | default: { 431| | skip_number(ctx, it, end); 432| | } 433| | } 434| | } 435| 5.16M| } _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_QntdtT_8commentsEEvOT0_OT1_T2_: 321| 821k| { 322| 821k| using namespace glz::detail; 323| | 324| | // Validating skips (parse_value/JSON pointer) require the full value in a 325| | // contiguous buffer, so streaming refill is not applied there. 326| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 327| | if (ctx.stream.enabled()) { 328| | skip_value_streaming(ctx, it, end); 329| | return; 330| | } 331| | } 332| | 333| | if constexpr (not check_validate_skipped(Opts)) { 334| | if constexpr (not check_ws_handled(Opts)) { 335| | if (skip_ws(ctx, it, end)) { 336| | return; 337| | } 338| | } 339| | while (true) { 340| | switch (*it) { 341| | case '{': 342| | ++it; 343| | if constexpr (not Opts.null_terminated) { 344| | if (it == end) [[unlikely]] { 345| | ctx.error = error_code::unexpected_end; 346| | return; 347| | } 348| | } 349| | skip_until_closed(ctx, it, end); 350| | if (bool(ctx.error)) [[unlikely]] 351| | return; 352| | break; 353| | case '[': 354| | ++it; 355| | if constexpr (not Opts.null_terminated) { 356| | if (it == end) [[unlikely]] { 357| | ctx.error = error_code::unexpected_end; 358| | return; 359| | } 360| | } 361| | skip_until_closed(ctx, it, end); 362| | if (bool(ctx.error)) [[unlikely]] 363| | return; 364| | break; 365| | case '"': 366| | skip_string(ctx, it, end); 367| | if (bool(ctx.error)) [[unlikely]] 368| | return; 369| | break; 370| | case ',': 371| | case '}': 372| | case ']': 373| | break; 374| | case '\0': 375| | ctx.error = error_code::unexpected_end; 376| | return; 377| | default: { 378| | ++it; 379| | if constexpr (not Opts.null_terminated) { 380| | if (it == end) [[unlikely]] { 381| | ctx.error = error_code::unexpected_end; 382| | return; 383| | } 384| | } 385| | continue; 386| | } 387| | } 388| | 389| | break; 390| | } 391| | } 392| 821k| else { 393| 821k| if constexpr (not check_ws_handled(Opts)) { 394| 821k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (394:17): [True: 13, False: 821k] ------------------ 395| 13| return; 396| 13| } 397| 821k| } 398| 821k| switch (*it) { 399| 91.8k| case '{': { ------------------ | Branch (399:10): [True: 91.8k, False: 730k] ------------------ 400| 91.8k| skip_object(ctx, it, end); 401| 91.8k| break; 402| 0| } 403| 359k| case '[': { ------------------ | Branch (403:10): [True: 359k, False: 461k] ------------------ 404| 359k| skip_array(ctx, it, end); 405| 359k| break; 406| 0| } 407| 55.5k| case '"': { ------------------ | Branch (407:10): [True: 55.5k, False: 766k] ------------------ 408| 55.5k| skip_string(ctx, it, end); 409| 55.5k| break; 410| 0| } 411| 5.30k| case 'n': { ------------------ | Branch (411:10): [True: 5.30k, False: 816k] ------------------ 412| 5.30k| ++it; 413| 5.30k| match<"ull", Opts>(ctx, it, end); 414| 5.30k| break; 415| 0| } 416| 4.48k| case 'f': { ------------------ | Branch (416:10): [True: 4.48k, False: 817k] ------------------ 417| 4.48k| ++it; 418| 4.48k| match<"alse", Opts>(ctx, it, end); 419| 4.48k| break; 420| 0| } 421| 3.32k| case 't': { ------------------ | Branch (421:10): [True: 3.32k, False: 818k] ------------------ 422| 3.32k| ++it; 423| 3.32k| match<"rue", Opts>(ctx, it, end); 424| 3.32k| break; 425| 0| } 426| 1.31k| case '\0': { ------------------ | Branch (426:10): [True: 1.31k, False: 820k] ------------------ 427| 1.31k| ctx.error = error_code::unexpected_end; 428| 1.31k| break; 429| 0| } 430| 300k| default: { ------------------ | Branch (430:10): [True: 300k, False: 521k] ------------------ 431| 300k| skip_number(ctx, it, end); 432| 300k| } 433| 821k| } 434| 821k| } 435| 821k| } _ZN3glz11skip_objectITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_EEvOT0_OT1_T2_: 25| 91.8k| { 26| | if constexpr (!check_validate_skipped(Opts)) { 27| | ++it; 28| | if constexpr (not Opts.null_terminated) { 29| | if (it == end) [[unlikely]] { 30| | ctx.error = error_code::unexpected_end; 31| | return; 32| | } 33| | } 34| | skip_until_closed(ctx, it, end); 35| | } 36| 91.8k| else { 37| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 38| | // released at each syntactic close below 39| 91.8k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (39:14): [True: 194, False: 91.6k] ------------------ 40| 194| return; 41| 194| } 42| 91.6k| ++it; 43| 91.6k| if constexpr (not Opts.null_terminated) { 44| 91.6k| if (it == end) [[unlikely]] { ------------------ | Branch (44:17): [True: 4, False: 91.6k] ------------------ 45| 4| ctx.error = error_code::unexpected_end; 46| 4| return; 47| 4| } 48| 91.6k| } 49| 91.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (49:14): [True: 18, False: 91.5k] ------------------ 50| 18| return; 51| 18| } 52| 91.5k| if (*it == '}') { ------------------ | Branch (52:14): [True: 1.28k, False: 90.3k] ------------------ 53| 1.28k| --ctx.depth; 54| 1.28k| ++it; 55| 1.28k| if constexpr (not Opts.null_terminated) { 56| 1.28k| if (it == end) { ------------------ | Branch (56:20): [True: 2, False: 1.28k] ------------------ 57| 2| ctx.error = error_code::end_reached; 58| 2| return; 59| 2| } 60| 1.28k| } 61| 1.28k| return; 62| 1.28k| } 63| 147k| while (true) { ------------------ | Branch (63:17): [True: 147k, Folded] ------------------ 64| 147k| if (*it != '"') { ------------------ | Branch (64:17): [True: 16.8k, False: 131k] ------------------ 65| 16.8k| ctx.error = error_code::syntax_error; 66| 16.8k| return; 67| 16.8k| } 68| 131k| skip_string(ctx, it, end); 69| 131k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (69:17): [True: 3.81k, False: 127k] ------------------ 70| 3.81k| return; 71| 127k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (71:17): [True: 51, False: 127k] ------------------ 72| 51| return; 73| 51| } 74| 127k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (74:17): [True: 7.28k, False: 119k] ------------------ 75| 7.28k| return; 76| 7.28k| } 77| 119k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (77:17): [True: 6, False: 119k] ------------------ 78| 6| return; 79| 6| } 80| 119k| skip_value::op(ctx, it, end); 81| 119k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (81:17): [True: 26.3k, False: 93.5k] ------------------ 82| 26.3k| return; 83| 93.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (83:17): [True: 86, False: 93.4k] ------------------ 84| 86| return; 85| 86| } 86| 93.4k| if (*it != ',') break; ------------------ | Branch (86:17): [True: 35.8k, False: 57.6k] ------------------ 87| 57.6k| ++it; 88| 57.6k| if constexpr (not Opts.null_terminated) { 89| 57.6k| if (it == end) [[unlikely]] { ------------------ | Branch (89:20): [True: 2, False: 57.6k] ------------------ 90| 2| ctx.error = error_code::unexpected_end; 91| 2| return; 92| 2| } 93| 57.6k| } 94| 57.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (94:17): [True: 6, False: 57.6k] ------------------ 95| 6| return; 96| 6| } 97| 57.6k| } 98| 35.8k| match<'}'>(ctx, it); 99| 35.8k| --ctx.depth; 100| 35.8k| if constexpr (not Opts.null_terminated) { 101| 35.8k| if (it == end) { ------------------ | Branch (101:17): [True: 20.4k, False: 15.4k] ------------------ 102| 20.4k| ctx.error = error_code::end_reached; 103| 20.4k| return; 104| 20.4k| } 105| 35.8k| } 106| 35.8k| } 107| 91.8k| } _ZN3glz10skip_arrayITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QooeqdtT_6formatL_ZNS_4JSONEEeqdtT_6formatL_ZNS_6NDJSONEEEEvOT0_OT1_T2_: 112| 359k| { 113| | if constexpr (!check_validate_skipped(Opts)) { 114| | ++it; 115| | if constexpr (not Opts.null_terminated) { 116| | if (it == end) [[unlikely]] { 117| | ctx.error = error_code::unexpected_end; 118| | return; 119| | } 120| | } 121| | skip_until_closed(ctx, it, end); 122| | } 123| 359k| else { 124| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 125| | // released at each syntactic close below 126| 359k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (126:14): [True: 944, False: 358k] ------------------ 127| 944| return; 128| 944| } 129| 358k| ++it; 130| 358k| if constexpr (not Opts.null_terminated) { 131| 358k| if (it == end) [[unlikely]] { ------------------ | Branch (131:17): [True: 3, False: 358k] ------------------ 132| 3| ctx.error = error_code::unexpected_end; 133| 3| return; 134| 3| } 135| 358k| } 136| 358k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (136:14): [True: 2, False: 358k] ------------------ 137| 2| return; 138| 2| } 139| 358k| if (*it == ']') { ------------------ | Branch (139:14): [True: 2.04k, False: 356k] ------------------ 140| 2.04k| --ctx.depth; 141| 2.04k| ++it; 142| 2.04k| if constexpr (not Opts.null_terminated) { 143| 2.04k| if (it == end) { ------------------ | Branch (143:20): [True: 690, False: 1.35k] ------------------ 144| 690| ctx.error = error_code::end_reached; 145| 690| return; 146| 690| } 147| 2.04k| } 148| 1.35k| return; 149| 2.04k| } 150| 384k| while (true) { ------------------ | Branch (150:17): [True: 384k, Folded] ------------------ 151| 384k| skip_value::op(ctx, it, end); 152| 384k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (152:17): [True: 343k, False: 40.7k] ------------------ 153| 343k| return; 154| 40.7k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (154:17): [True: 4, False: 40.7k] ------------------ 155| 4| return; 156| 4| } 157| 40.7k| if (*it != ',') break; ------------------ | Branch (157:17): [True: 13.2k, False: 27.5k] ------------------ 158| 27.5k| ++it; 159| 27.5k| if constexpr (not Opts.null_terminated) { 160| 27.5k| if (it == end) [[unlikely]] { ------------------ | Branch (160:20): [True: 1, False: 27.5k] ------------------ 161| 1| ctx.error = error_code::unexpected_end; 162| 1| return; 163| 1| } 164| 27.5k| } 165| 27.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (165:17): [True: 1, False: 27.5k] ------------------ 166| 1| return; 167| 1| } 168| 27.5k| } 169| 13.2k| match<']'>(ctx, it); 170| 13.2k| --ctx.depth; 171| 13.2k| if constexpr (not Opts.null_terminated) { 172| 13.2k| if (it == end) { ------------------ | Branch (172:17): [True: 274, False: 12.9k] ------------------ 173| 274| ctx.error = error_code::end_reached; 174| 274| return; 175| 274| } 176| 13.2k| } 177| 13.2k| } 178| 359k| } _ZN3glz11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEDaOT0_OT1_T2_: 308| 14.1k| { 309| 14.1k| auto start = it; 310| 14.1k| struct opts_validate_skipped : std::decay_t 311| 14.1k| { 312| 14.1k| bool validate_skipped = true; 313| 14.1k| }; 314| 14.1k| skip_value::op(ctx, it, end); 315| 14.1k| return std::span{start, size_t(it - start)}; 316| 14.1k| } _ZN3glz10skip_valueILj10EE2opITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS4_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES6_S9_S8_QntdtT_8commentsEEvSB_SD_SE_: 321| 39.9k| { 322| 39.9k| using namespace glz::detail; 323| | 324| | // Validating skips (parse_value/JSON pointer) require the full value in a 325| | // contiguous buffer, so streaming refill is not applied there. 326| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 327| | if (ctx.stream.enabled()) { 328| | skip_value_streaming(ctx, it, end); 329| | return; 330| | } 331| | } 332| | 333| | if constexpr (not check_validate_skipped(Opts)) { 334| | if constexpr (not check_ws_handled(Opts)) { 335| | if (skip_ws(ctx, it, end)) { 336| | return; 337| | } 338| | } 339| | while (true) { 340| | switch (*it) { 341| | case '{': 342| | ++it; 343| | if constexpr (not Opts.null_terminated) { 344| | if (it == end) [[unlikely]] { 345| | ctx.error = error_code::unexpected_end; 346| | return; 347| | } 348| | } 349| | skip_until_closed(ctx, it, end); 350| | if (bool(ctx.error)) [[unlikely]] 351| | return; 352| | break; 353| | case '[': 354| | ++it; 355| | if constexpr (not Opts.null_terminated) { 356| | if (it == end) [[unlikely]] { 357| | ctx.error = error_code::unexpected_end; 358| | return; 359| | } 360| | } 361| | skip_until_closed(ctx, it, end); 362| | if (bool(ctx.error)) [[unlikely]] 363| | return; 364| | break; 365| | case '"': 366| | skip_string(ctx, it, end); 367| | if (bool(ctx.error)) [[unlikely]] 368| | return; 369| | break; 370| | case ',': 371| | case '}': 372| | case ']': 373| | break; 374| | case '\0': 375| | ctx.error = error_code::unexpected_end; 376| | return; 377| | default: { 378| | ++it; 379| | if constexpr (not Opts.null_terminated) { 380| | if (it == end) [[unlikely]] { 381| | ctx.error = error_code::unexpected_end; 382| | return; 383| | } 384| | } 385| | continue; 386| | } 387| | } 388| | 389| | break; 390| | } 391| | } 392| 39.9k| else { 393| 39.9k| if constexpr (not check_ws_handled(Opts)) { 394| 39.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (394:17): [True: 0, False: 39.9k] ------------------ 395| 0| return; 396| 0| } 397| 39.9k| } 398| 39.9k| switch (*it) { 399| 3.07k| case '{': { ------------------ | Branch (399:10): [True: 3.07k, False: 36.8k] ------------------ 400| 3.07k| skip_object(ctx, it, end); 401| 3.07k| break; 402| 0| } 403| 3.20k| case '[': { ------------------ | Branch (403:10): [True: 3.20k, False: 36.7k] ------------------ 404| 3.20k| skip_array(ctx, it, end); 405| 3.20k| break; 406| 0| } 407| 3.26k| case '"': { ------------------ | Branch (407:10): [True: 3.26k, False: 36.6k] ------------------ 408| 3.26k| skip_string(ctx, it, end); 409| 3.26k| break; 410| 0| } 411| 845| case 'n': { ------------------ | Branch (411:10): [True: 845, False: 39.1k] ------------------ 412| 845| ++it; 413| 845| match<"ull", Opts>(ctx, it, end); 414| 845| break; 415| 0| } 416| 872| case 'f': { ------------------ | Branch (416:10): [True: 872, False: 39.0k] ------------------ 417| 872| ++it; 418| 872| match<"alse", Opts>(ctx, it, end); 419| 872| break; 420| 0| } 421| 905| case 't': { ------------------ | Branch (421:10): [True: 905, False: 39.0k] ------------------ 422| 905| ++it; 423| 905| match<"rue", Opts>(ctx, it, end); 424| 905| break; 425| 0| } 426| 0| case '\0': { ------------------ | Branch (426:10): [True: 0, False: 39.9k] ------------------ 427| 0| ctx.error = error_code::unexpected_end; 428| 0| break; 429| 0| } 430| 27.8k| default: { ------------------ | Branch (430:10): [True: 27.8k, False: 12.1k] ------------------ 431| 27.8k| skip_number(ctx, it, end); 432| 27.8k| } 433| 39.9k| } 434| 39.9k| } 435| 39.9k| } _ZN3glz11skip_objectITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS6_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS2_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES4_S7_S6_EEvS9_SB_SC_: 25| 3.07k| { 26| | if constexpr (!check_validate_skipped(Opts)) { 27| | ++it; 28| | if constexpr (not Opts.null_terminated) { 29| | if (it == end) [[unlikely]] { 30| | ctx.error = error_code::unexpected_end; 31| | return; 32| | } 33| | } 34| | skip_until_closed(ctx, it, end); 35| | } 36| 3.07k| else { 37| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 38| | // released at each syntactic close below 39| 3.07k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (39:14): [True: 0, False: 3.07k] ------------------ 40| 0| return; 41| 0| } 42| 3.07k| ++it; 43| 3.07k| if constexpr (not Opts.null_terminated) { 44| 3.07k| if (it == end) [[unlikely]] { ------------------ | Branch (44:17): [True: 0, False: 3.07k] ------------------ 45| 0| ctx.error = error_code::unexpected_end; 46| 0| return; 47| 0| } 48| 3.07k| } 49| 3.07k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (49:14): [True: 0, False: 3.07k] ------------------ 50| 0| return; 51| 0| } 52| 3.07k| if (*it == '}') { ------------------ | Branch (52:14): [True: 535, False: 2.53k] ------------------ 53| 535| --ctx.depth; 54| 535| ++it; 55| 535| if constexpr (not Opts.null_terminated) { 56| 535| if (it == end) { ------------------ | Branch (56:20): [True: 0, False: 535] ------------------ 57| 0| ctx.error = error_code::end_reached; 58| 0| return; 59| 0| } 60| 535| } 61| 535| return; 62| 535| } 63| 10.1k| while (true) { ------------------ | Branch (63:17): [True: 10.1k, Folded] ------------------ 64| 10.1k| if (*it != '"') { ------------------ | Branch (64:17): [True: 0, False: 10.1k] ------------------ 65| 0| ctx.error = error_code::syntax_error; 66| 0| return; 67| 0| } 68| 10.1k| skip_string(ctx, it, end); 69| 10.1k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (69:17): [True: 0, False: 10.1k] ------------------ 70| 0| return; 71| 10.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (71:17): [True: 0, False: 10.1k] ------------------ 72| 0| return; 73| 0| } 74| 10.1k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (74:17): [True: 0, False: 10.1k] ------------------ 75| 0| return; 76| 0| } 77| 10.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (77:17): [True: 0, False: 10.1k] ------------------ 78| 0| return; 79| 0| } 80| 10.1k| skip_value::op(ctx, it, end); 81| 10.1k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (81:17): [True: 0, False: 10.1k] ------------------ 82| 0| return; 83| 10.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (83:17): [True: 0, False: 10.1k] ------------------ 84| 0| return; 85| 0| } 86| 10.1k| if (*it != ',') break; ------------------ | Branch (86:17): [True: 2.53k, False: 7.60k] ------------------ 87| 7.60k| ++it; 88| 7.60k| if constexpr (not Opts.null_terminated) { 89| 7.60k| if (it == end) [[unlikely]] { ------------------ | Branch (89:20): [True: 0, False: 7.60k] ------------------ 90| 0| ctx.error = error_code::unexpected_end; 91| 0| return; 92| 0| } 93| 7.60k| } 94| 7.60k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (94:17): [True: 0, False: 7.60k] ------------------ 95| 0| return; 96| 0| } 97| 7.60k| } 98| 2.53k| match<'}'>(ctx, it); 99| 2.53k| --ctx.depth; 100| 2.53k| if constexpr (not Opts.null_terminated) { 101| 2.53k| if (it == end) { ------------------ | Branch (101:17): [True: 0, False: 2.53k] ------------------ 102| 0| ctx.error = error_code::end_reached; 103| 0| return; 104| 0| } 105| 2.53k| } 106| 2.53k| } 107| 3.07k| } _ZN3glz10skip_arrayITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS6_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS2_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES4_S7_S6_QooeqdtT_6formatL_ZNS_4JSONEEeqdtT_6formatL_ZNS_6NDJSONEEEEvS9_SB_SC_: 112| 3.20k| { 113| | if constexpr (!check_validate_skipped(Opts)) { 114| | ++it; 115| | if constexpr (not Opts.null_terminated) { 116| | if (it == end) [[unlikely]] { 117| | ctx.error = error_code::unexpected_end; 118| | return; 119| | } 120| | } 121| | skip_until_closed(ctx, it, end); 122| | } 123| 3.20k| else { 124| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 125| | // released at each syntactic close below 126| 3.20k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (126:14): [True: 0, False: 3.20k] ------------------ 127| 0| return; 128| 0| } 129| 3.20k| ++it; 130| 3.20k| if constexpr (not Opts.null_terminated) { 131| 3.20k| if (it == end) [[unlikely]] { ------------------ | Branch (131:17): [True: 0, False: 3.20k] ------------------ 132| 0| ctx.error = error_code::unexpected_end; 133| 0| return; 134| 0| } 135| 3.20k| } 136| 3.20k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (136:14): [True: 0, False: 3.20k] ------------------ 137| 0| return; 138| 0| } 139| 3.20k| if (*it == ']') { ------------------ | Branch (139:14): [True: 378, False: 2.82k] ------------------ 140| 378| --ctx.depth; 141| 378| ++it; 142| 378| if constexpr (not Opts.null_terminated) { 143| 378| if (it == end) { ------------------ | Branch (143:20): [True: 0, False: 378] ------------------ 144| 0| ctx.error = error_code::end_reached; 145| 0| return; 146| 0| } 147| 378| } 148| 378| return; 149| 378| } 150| 15.6k| while (true) { ------------------ | Branch (150:17): [True: 15.6k, Folded] ------------------ 151| 15.6k| skip_value::op(ctx, it, end); 152| 15.6k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (152:17): [True: 0, False: 15.6k] ------------------ 153| 0| return; 154| 15.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (154:17): [True: 0, False: 15.6k] ------------------ 155| 0| return; 156| 0| } 157| 15.6k| if (*it != ',') break; ------------------ | Branch (157:17): [True: 2.82k, False: 12.8k] ------------------ 158| 12.8k| ++it; 159| 12.8k| if constexpr (not Opts.null_terminated) { 160| 12.8k| if (it == end) [[unlikely]] { ------------------ | Branch (160:20): [True: 0, False: 12.8k] ------------------ 161| 0| ctx.error = error_code::unexpected_end; 162| 0| return; 163| 0| } 164| 12.8k| } 165| 12.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (165:17): [True: 0, False: 12.8k] ------------------ 166| 0| return; 167| 0| } 168| 12.8k| } 169| 2.82k| match<']'>(ctx, it); 170| 2.82k| --ctx.depth; 171| 2.82k| if constexpr (not Opts.null_terminated) { 172| 2.82k| if (it == end) { ------------------ | Branch (172:17): [True: 0, False: 2.82k] ------------------ 173| 0| ctx.error = error_code::end_reached; 174| 0| return; 175| 0| } 176| 2.82k| } 177| 2.82k| } 178| 3.20k| } _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_: 2840| 47.1k| { 2841| 47.1k| return write(std::forward(value)); 2842| 47.1k| } _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 47.1k| { 846| | if constexpr (check_string_as_number(Opts)) { 847| | const sv str = [&]() -> const sv { 848| | if constexpr (array_char_t) { 849| | const auto* start = value.data(); 850| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 851| | return sv{start, end ? size_t(end - start) : value.size()}; 852| | } 853| | else if constexpr (u8str_t) { 854| | return sv{reinterpret_cast(value.data()), value.size()}; 855| | } 856| | else { 857| | return str_view(value); 858| | } 859| | }(); 860| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 861| | return; 862| | } 863| | dump_maybe_empty(str, b, ix); 864| | } 865| | else if constexpr (char_t) { 866| | if constexpr (check_unquoted(Opts)) { 867| | dump(value, b, ix); 868| | } 869| | else { 870| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 871| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 872| | return; 873| | } 874| | 875| | std::memcpy(&b[ix], "\"", 1); 876| | ++ix; 877| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 878| | std::memcpy(&b[ix], &escaped, 2); 879| | ix += 2; 880| | } 881| | else if (value == '\0') { 882| | // null character treated as empty string 883| | } 884| | else if constexpr (check_escape_control_characters(Opts)) { 885| | if (uint8_t(value) < 0x20) { 886| | // Write as \uXXXX format 887| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 888| | constexpr char hex_digits[] = "0123456789ABCDEF"; 889| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 890| | unicode_escape[5] = hex_digits[value & 0xF]; 891| | std::memcpy(&b[ix], unicode_escape, 6); 892| | ix += 6; 893| | } 894| | else { 895| | std::memcpy(&b[ix], &value, 1); 896| | ++ix; 897| | } 898| | } 899| | else { 900| | if constexpr (check_reject_control_characters(Opts)) { 901| | if (uint8_t(value) < 0x20) [[unlikely]] { 902| | ctx.error = error_code::invalid_control_character; 903| | } 904| | } 905| | std::memcpy(&b[ix], &value, 1); 906| | ++ix; 907| | } 908| | std::memcpy(&b[ix], "\"", 1); 909| | ++ix; 910| | } 911| | } 912| 47.1k| else { 913| | if constexpr (check_raw_string(Opts)) { 914| | const sv str = [&]() -> const sv { 915| | if constexpr (u8str_t) { 916| | return sv{reinterpret_cast(value.data()), value.size()}; 917| | } 918| | else { 919| | return str_view(value); 920| | } 921| | }(); 922| | 923| | // We need space for quotes and the string length: 2 + n. 924| | // Use +8 for extra buffer 925| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 926| | return; 927| | } 928| | // now we don't have to check writing 929| | 930| | if constexpr (not check_unquoted(Opts)) { 931| | std::memcpy(&b[ix], "\"", 1); 932| | ++ix; 933| | } 934| | if (str.size()) [[likely]] { 935| | const auto n = str.size(); 936| | std::memcpy(&b[ix], str.data(), n); 937| | ix += n; 938| | } 939| | if constexpr (not check_unquoted(Opts)) { 940| | std::memcpy(&b[ix], "\"", 1); 941| | ++ix; 942| | } 943| | } 944| 47.1k| else { 945| 47.1k| const sv str = [&]() -> const sv { 946| 47.1k| if constexpr (array_char_t) { 947| 47.1k| return sv{value.data(), value.size()}; 948| 47.1k| } 949| 47.1k| else if constexpr (u8str_t) { 950| 47.1k| return sv{reinterpret_cast(value.data()), value.size()}; 951| 47.1k| } 952| 47.1k| else { 953| 47.1k| return str_view(value); 954| 47.1k| } 955| 47.1k| }(); 956| 47.1k| const auto n = str.size(); 957| | 958| | // In the case n == 0 we need two characters for quotes. 959| | // For each individual character we need room for two characters to handle escapes. 960| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 961| | if constexpr (check_escape_control_characters(Opts)) { 962| | if constexpr (has_bounded_capacity) { 963| | // 6 bytes per character is a ceiling only a string of nothing but control 964| | // characters reaches. A resizable buffer merely over-allocates against it, 965| | // but a fixed buffer has nowhere to grow, so the ceiling would reject output 966| | // that fits. Measuring the string answers exactly, at the cost of a pass over 967| | // it, so bracket the measurement between two O(1) bounds and only pay it when 968| | // the answer is still in doubt: the ceiling fitting means yes, and the floor 969| | // of one byte per character not fitting means no. 970| | const size_t capacity = buffer_traits>::capacity(b); 971| | size_t required = ix + 10 + 6 * n; 972| | if (required > capacity) [[unlikely]] { 973| | required = ix + 10 + n; 974| | if (required <= capacity) { 975| | required = ix + 10 + detail::escaped_string_size(str); 976| | } 977| | } 978| | if (!ensure_space(ctx, b, required)) [[unlikely]] { 979| | return; 980| | } 981| | } 982| | // We need 2 + 6 * n characters in the worst case (all control chars) 983| | else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 984| | return; 985| | } 986| | } 987| 47.1k| else { 988| | // Using the original sizing 989| 47.1k| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 47.1k] ------------------ 990| 0| return; 991| 0| } 992| 47.1k| } 993| | // now we don't have to check writing 994| | 995| | if constexpr (check_unquoted(Opts)) { 996| | if (n) { 997| | std::memcpy(&b[ix], str.data(), n); 998| | ix += n; 999| | } 1000| | } 1001| 47.1k| else { 1002| 47.1k| std::memcpy(&b[ix], "\"", 1); 1003| 47.1k| ++ix; 1004| | 1005| 47.1k| const auto* c = str.data(); 1006| 47.1k| const auto* const e = c + n; 1007| 47.1k| const auto start = &b[ix]; 1008| 47.1k| auto data = start; 1009| | 1010| | // By default we don't escape control characters for performance. Invalid JSON characters 1011| | // result in null characters in the output, making the JSON invalid — these would then be 1012| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 1013| | // control characters (0x00–0x1F) as \uXXXX sequences. 1014| | 1015| | // Escape handler: writes the escaped form of *c into data, advances both pointers 1016| 47.1k| auto write_escape = [&]() { 1017| 47.1k| if constexpr (check_escape_control_characters(Opts)) { 1018| 47.1k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 47.1k| std::memcpy(data, &escaped, 2); 1020| 47.1k| data += 2; 1021| 47.1k| } 1022| 47.1k| else { 1023| 47.1k| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 47.1k| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 47.1k| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 47.1k| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 47.1k| std::memcpy(data, unicode_escape, 6); 1028| 47.1k| data += 6; 1029| 47.1k| } 1030| 47.1k| } 1031| 47.1k| else { 1032| 47.1k| if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| 47.1k| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 47.1k| ctx.error = error_code::invalid_control_character; 1040| 47.1k| } 1041| 47.1k| } 1042| 47.1k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 47.1k| data += 2; 1044| 47.1k| } 1045| 47.1k| ++c; 1046| 47.1k| }; 1047| | 1048| | // Adding a helper here means adding a branch to string_escape_simd() in 1049| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 1050| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 1051| |#if defined(GLZ_USE_AVX2) 1052| | detail::avx2_string_escape(c, e, data, n, write_escape); 1053| |#endif 1054| 47.1k|#if defined(GLZ_USE_SSE2) 1055| 47.1k| detail::sse2_string_escape(c, e, data, n, write_escape); 1056| |#elif defined(GLZ_USE_NEON) 1057| | detail::neon_string_escape(c, e, data, n, write_escape); 1058| |#endif 1059| | 1060| | // SWAR: 8 bytes at a time 1061| 47.1k| if (n > 7) { ------------------ | Branch (1061:23): [True: 47.1k, False: 0] ------------------ 1062| 90.9k| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 43.7k, False: 47.1k] ------------------ 1063| 43.7k| std::memcpy(data, c, 8); 1064| 43.7k| uint64_t swar; 1065| 43.7k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 43.7k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 43.7k| const uint64_t lo7 = swar & lo7_mask; 1072| 43.7k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 43.7k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 43.7k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 43.7k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 43.7k| next &= repeat_byte8(0b10000000); 1078| 43.7k| if (next == 0) { ------------------ | Branch (1078:29): [True: 32.6k, False: 11.1k] ------------------ 1079| 32.6k| data += 8; 1080| 32.6k| c += 8; 1081| 32.6k| continue; 1082| 32.6k| } 1083| | 1084| 11.1k| const auto length = (countr_zero(next) >> 3); 1085| 11.1k| c += length; 1086| 11.1k| data += length; 1087| 11.1k| write_escape(); 1088| 11.1k| } 1089| 47.1k| } 1090| | 1091| | // Scalar tail 1092| 208k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 161k, False: 47.1k] ------------------ 1093| 161k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 2.35k, False: 158k] ------------------ 1094| 2.35k| std::memcpy(data, &escaped, 2); 1095| 2.35k| data += 2; 1096| 2.35k| } 1097| | else if constexpr (check_escape_control_characters(Opts)) { 1098| | if (uint8_t(*c) < 0x20) { 1099| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1100| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1101| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1102| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1103| | std::memcpy(data, unicode_escape, 6); 1104| | data += 6; 1105| | } 1106| | else { 1107| | std::memcpy(data, c, 1); 1108| | ++data; 1109| | } 1110| | } 1111| 158k| else { 1112| | if constexpr (check_reject_control_characters(Opts)) { 1113| | if (uint8_t(*c) < 0x20) [[unlikely]] { 1114| | ctx.error = error_code::invalid_control_character; 1115| | } 1116| | } 1117| 158k| std::memcpy(data, c, 1); 1118| 158k| ++data; 1119| 158k| } 1120| 161k| } 1121| | 1122| 47.1k| ix += size_t(data - start); 1123| | 1124| 47.1k| std::memcpy(&b[ix], "\"", 1); 1125| 47.1k| ++ix; 1126| 47.1k| } 1127| 47.1k| } 1128| 47.1k| } 1129| 47.1k| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 47.1k| const sv str = [&]() -> const sv { 946| | if constexpr (array_char_t) { 947| | return sv{value.data(), value.size()}; 948| | } 949| | else if constexpr (u8str_t) { 950| | return sv{reinterpret_cast(value.data()), value.size()}; 951| | } 952| 47.1k| else { 953| 47.1k| return str_view(value); 954| 47.1k| } 955| 47.1k| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 13.2M| auto write_escape = [&]() { 1017| | if constexpr (check_escape_control_characters(Opts)) { 1018| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| | std::memcpy(data, &escaped, 2); 1020| | data += 2; 1021| | } 1022| | else { 1023| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| | std::memcpy(data, unicode_escape, 6); 1028| | data += 6; 1029| | } 1030| | } 1031| 13.2M| else { 1032| | if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| | if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| | ctx.error = error_code::invalid_control_character; 1040| | } 1041| | } 1042| 13.2M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 13.2M| data += 2; 1044| 13.2M| } 1045| 13.2M| ++c; 1046| 13.2M| }; _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_: 2840| 44.4k| { 2841| 44.4k| return write(std::forward(value)); 2842| 44.4k| } _ZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1947| 44.4k| { 1948| | // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are 1949| | // written side by side whatever the alternative is. The visit below still instantiates in 1950| | // that mode (`if constexpr` does not discard the statements after it), but both of its 1951| | // tagged branches are compile-time dead there and the runtime `return` keeps it unreached. 1952| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) { 1953| | write_adjacent(value, ctx, b, ix); 1954| | return; 1955| | } 1956| 44.4k| std::visit( 1957| 44.4k| [&](auto&& val) { 1958| 44.4k| using V = std::decay_t; 1959| | 1960| 44.4k| if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| 44.4k| custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| 44.4k| if (missing_id(value, ctx)) { 1972| 44.4k| return; 1973| 44.4k| } 1974| 44.4k| using id_type = std::decay_t[value.index()])>; 1975| 44.4k| if constexpr (Opts.prettify) { 1976| 44.4k| dump("{\n", b, ix); 1977| 44.4k| ctx.depth += check_indentation_width(Opts); 1978| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| 44.4k| dump('"', b, ix); 1980| 44.4k| dump_maybe_empty(tag_v, b, ix); 1981| 44.4k| if constexpr (std::integral) { 1982| 44.4k| dump("\": ", b, ix); 1983| 44.4k| serialize::op(ids_v[value.index()], ctx, b, ix); 1984| 44.4k| } 1985| 44.4k| else { 1986| 44.4k| dump("\": \"", b, ix); 1987| 44.4k| dump_maybe_empty(ids_v[value.index()], b, ix); 1988| 44.4k| dump('"', b, ix); 1989| 44.4k| } 1990| 44.4k| const auto pos_after_tag = ix; 1991| 44.4k| dump(",\n", b, ix); 1992| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| 44.4k| const auto pos_body_start = ix; 1994| 44.4k| to::template op()>(val, ctx, b, ix); 1995| 44.4k| if (ix == pos_body_start) { 1996| 44.4k| ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| 44.4k| } 1998| 44.4k| ctx.depth -= check_indentation_width(Opts); 1999| 44.4k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| 44.4k| return; 2001| 44.4k| } 2002| 44.4k| std::memcpy(&b[ix], "\n", 1); 2003| 44.4k| ++ix; 2004| 44.4k| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| 44.4k| ix += ctx.depth; 2006| 44.4k| std::memcpy(&b[ix], "}", 1); 2007| 44.4k| ++ix; 2008| 44.4k| } 2009| 44.4k| else { 2010| 44.4k| dump("{\"", b, ix); 2011| 44.4k| dump_maybe_empty(tag_v, b, ix); 2012| 44.4k| if constexpr (std::integral) { 2013| 44.4k| dump("\":", b, ix); 2014| 44.4k| serialize::op(ids_v[value.index()], ctx, b, ix); 2015| 44.4k| } 2016| 44.4k| else { 2017| 44.4k| dump("\":\"", b, ix); 2018| 44.4k| dump_maybe_empty(ids_v[value.index()], b, ix); 2019| 44.4k| dump('"', b, ix); 2020| 44.4k| } 2021| 44.4k| const auto pos_after_tag = ix; 2022| 44.4k| dump(',', b, ix); 2023| 44.4k| const auto pos_body_start = ix; 2024| 44.4k| to::template op()>(val, ctx, b, ix); 2025| 44.4k| if (ix == pos_body_start) { 2026| 44.4k| ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| 44.4k| } 2028| 44.4k| dump('}', b, ix); 2029| 44.4k| } 2030| 44.4k| } 2031| 44.4k| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| 44.4k| variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| 44.4k| if (missing_id(value, ctx)) { 2036| 44.4k| return; 2037| 44.4k| } 2038| 44.4k| if constexpr (Opts.prettify) { 2039| 44.4k| dump("{\n", b, ix); 2040| 44.4k| ctx.depth += check_indentation_width(Opts); 2041| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| 44.4k| dump('"', b, ix); 2043| 44.4k| dump_maybe_empty(tag_v, b, ix); 2044| 44.4k| dump("\": ", b, ix); 2045| 44.4k| write_id(value, ctx, b, ix); 2046| 44.4k| ctx.depth -= check_indentation_width(Opts); 2047| 44.4k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| 44.4k| return; 2049| 44.4k| } 2050| 44.4k| std::memcpy(&b[ix], "\n", 1); 2051| 44.4k| ++ix; 2052| 44.4k| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| 44.4k| ix += ctx.depth; 2054| 44.4k| std::memcpy(&b[ix], "}", 1); 2055| 44.4k| ++ix; 2056| 44.4k| } 2057| 44.4k| else { 2058| 44.4k| dump("{\"", b, ix); 2059| 44.4k| dump_maybe_empty(tag_v, b, ix); 2060| 44.4k| dump("\":", b, ix); 2061| 44.4k| write_id(value, ctx, b, ix); 2062| 44.4k| dump('}', b, ix); 2063| 44.4k| } 2064| 44.4k| } 2065| 44.4k| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| 44.4k| (glaze_object_t || reflectable || is_memory_object) && 2067| 44.4k| (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| 44.4k| if (missing_id(value, ctx)) { 2073| 44.4k| return; 2074| 44.4k| } 2075| 44.4k| constexpr auto N = []() { 2076| 44.4k| if constexpr (is_memory_object) { 2077| 44.4k| return reflect>::size; 2078| 44.4k| } 2079| 44.4k| else { 2080| 44.4k| return reflect::size; 2081| 44.4k| } 2082| 44.4k| }(); 2083| | 2084| | // must first write out type 2085| 44.4k| if constexpr (Opts.prettify) { 2086| 44.4k| dump("{\n", b, ix); 2087| 44.4k| ctx.depth += check_indentation_width(Opts); 2088| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| 44.4k| dump('"', b, ix); 2090| 44.4k| dump_maybe_empty(tag_v, b, ix); 2091| | 2092| 44.4k| using id_type = std::decay_t[value.index()])>; 2093| | 2094| 44.4k| if constexpr (std::integral) { 2095| 44.4k| dump("\": ", b, ix); 2096| 44.4k| serialize::op(ids_v[value.index()], ctx, b, ix); 2097| 44.4k| if constexpr (N > 0) { 2098| 44.4k| dump(",\n", b, ix); 2099| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| 44.4k| } 2101| 44.4k| } 2102| 44.4k| else { 2103| 44.4k| dump("\": \"", b, ix); 2104| 44.4k| dump_maybe_empty(ids_v[value.index()], b, ix); 2105| 44.4k| if constexpr (N == 0) { 2106| 44.4k| dump('"', b, ix); 2107| 44.4k| } 2108| 44.4k| else { 2109| 44.4k| dump("\",\n", b, ix); 2110| 44.4k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| 44.4k| } 2112| 44.4k| } 2113| 44.4k| } 2114| 44.4k| else { 2115| 44.4k| using id_type = std::decay_t[value.index()])>; 2116| | 2117| 44.4k| dump("{\"", b, ix); 2118| 44.4k| dump_maybe_empty(tag_v, b, ix); 2119| | 2120| 44.4k| if constexpr (std::integral) { 2121| 44.4k| dump("\":", b, ix); 2122| 44.4k| serialize::op(ids_v[value.index()], ctx, b, ix); 2123| 44.4k| if constexpr (N > 0) { 2124| 44.4k| dump(',', b, ix); 2125| 44.4k| } 2126| 44.4k| } 2127| 44.4k| else { 2128| 44.4k| dump("\":\"", b, ix); 2129| 44.4k| dump_maybe_empty(ids_v[value.index()], b, ix); 2130| 44.4k| if constexpr (N == 0) { 2131| 44.4k| dump('"', b, ix); 2132| 44.4k| } 2133| 44.4k| else { 2134| 44.4k| dump("\",", b, ix); 2135| 44.4k| } 2136| 44.4k| } 2137| 44.4k| } 2138| 44.4k| if constexpr (is_memory_object) { 2139| 44.4k| if (!val) [[unlikely]] { 2140| 44.4k| ctx.error = error_code::invalid_variant_object; 2141| 44.4k| return; 2142| 44.4k| } 2143| 44.4k| to>::template op()>(*val, ctx, b, ix); 2144| 44.4k| } 2145| 44.4k| else { 2146| 44.4k| to::template op()>(val, ctx, b, ix); 2147| 44.4k| } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| 44.4k| if constexpr (Opts.skip_null_members) { 2150| 44.4k| if (b[ix - 1] == ',') { 2151| 44.4k| --ix; 2152| 44.4k| } 2153| 44.4k| } 2154| | 2155| 44.4k| if constexpr (Opts.prettify) { 2156| 44.4k| ctx.depth -= check_indentation_width(Opts); 2157| 44.4k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| 44.4k| return; 2159| 44.4k| } 2160| 44.4k| std::memcpy(&b[ix], "\n", 1); 2161| 44.4k| ++ix; 2162| 44.4k| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| 44.4k| ix += ctx.depth; 2164| 44.4k| std::memcpy(&b[ix], "}", 1); 2165| 44.4k| ++ix; 2166| 44.4k| } 2167| 44.4k| else { 2168| 44.4k| dump('}', b, ix); 2169| 44.4k| } 2170| 44.4k| } 2171| 44.4k| else { 2172| 44.4k| to::template op(val, ctx, b, ix); 2173| 44.4k| } 2174| 44.4k| }, 2175| 44.4k| value); 2176| 44.4k| } _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRDnEEDaSS_: 1957| 8.11k| [&](auto&& val) { 1958| 8.11k| using V = std::decay_t; 1959| | 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| | custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| | if (missing_id(value, ctx)) { 1972| | return; 1973| | } 1974| | using id_type = std::decay_t[value.index()])>; 1975| | if constexpr (Opts.prettify) { 1976| | dump("{\n", b, ix); 1977| | ctx.depth += check_indentation_width(Opts); 1978| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| | dump('"', b, ix); 1980| | dump_maybe_empty(tag_v, b, ix); 1981| | if constexpr (std::integral) { 1982| | dump("\": ", b, ix); 1983| | serialize::op(ids_v[value.index()], ctx, b, ix); 1984| | } 1985| | else { 1986| | dump("\": \"", b, ix); 1987| | dump_maybe_empty(ids_v[value.index()], b, ix); 1988| | dump('"', b, ix); 1989| | } 1990| | const auto pos_after_tag = ix; 1991| | dump(",\n", b, ix); 1992| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| | const auto pos_body_start = ix; 1994| | to::template op()>(val, ctx, b, ix); 1995| | if (ix == pos_body_start) { 1996| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| | } 1998| | ctx.depth -= check_indentation_width(Opts); 1999| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| | return; 2001| | } 2002| | std::memcpy(&b[ix], "\n", 1); 2003| | ++ix; 2004| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| | ix += ctx.depth; 2006| | std::memcpy(&b[ix], "}", 1); 2007| | ++ix; 2008| | } 2009| | else { 2010| | dump("{\"", b, ix); 2011| | dump_maybe_empty(tag_v, b, ix); 2012| | if constexpr (std::integral) { 2013| | dump("\":", b, ix); 2014| | serialize::op(ids_v[value.index()], ctx, b, ix); 2015| | } 2016| | else { 2017| | dump("\":\"", b, ix); 2018| | dump_maybe_empty(ids_v[value.index()], b, ix); 2019| | dump('"', b, ix); 2020| | } 2021| | const auto pos_after_tag = ix; 2022| | dump(',', b, ix); 2023| | const auto pos_body_start = ix; 2024| | to::template op()>(val, ctx, b, ix); 2025| | if (ix == pos_body_start) { 2026| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| | } 2028| | dump('}', b, ix); 2029| | } 2030| | } 2031| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| | variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| | if (missing_id(value, ctx)) { 2036| | return; 2037| | } 2038| | if constexpr (Opts.prettify) { 2039| | dump("{\n", b, ix); 2040| | ctx.depth += check_indentation_width(Opts); 2041| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| | dump('"', b, ix); 2043| | dump_maybe_empty(tag_v, b, ix); 2044| | dump("\": ", b, ix); 2045| | write_id(value, ctx, b, ix); 2046| | ctx.depth -= check_indentation_width(Opts); 2047| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| | return; 2049| | } 2050| | std::memcpy(&b[ix], "\n", 1); 2051| | ++ix; 2052| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| | ix += ctx.depth; 2054| | std::memcpy(&b[ix], "}", 1); 2055| | ++ix; 2056| | } 2057| | else { 2058| | dump("{\"", b, ix); 2059| | dump_maybe_empty(tag_v, b, ix); 2060| | dump("\":", b, ix); 2061| | write_id(value, ctx, b, ix); 2062| | dump('}', b, ix); 2063| | } 2064| | } 2065| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| | (glaze_object_t || reflectable || is_memory_object) && 2067| | (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| | if (missing_id(value, ctx)) { 2073| | return; 2074| | } 2075| | constexpr auto N = []() { 2076| | if constexpr (is_memory_object) { 2077| | return reflect>::size; 2078| | } 2079| | else { 2080| | return reflect::size; 2081| | } 2082| | }(); 2083| | 2084| | // must first write out type 2085| | if constexpr (Opts.prettify) { 2086| | dump("{\n", b, ix); 2087| | ctx.depth += check_indentation_width(Opts); 2088| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| | dump('"', b, ix); 2090| | dump_maybe_empty(tag_v, b, ix); 2091| | 2092| | using id_type = std::decay_t[value.index()])>; 2093| | 2094| | if constexpr (std::integral) { 2095| | dump("\": ", b, ix); 2096| | serialize::op(ids_v[value.index()], ctx, b, ix); 2097| | if constexpr (N > 0) { 2098| | dump(",\n", b, ix); 2099| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| | } 2101| | } 2102| | else { 2103| | dump("\": \"", b, ix); 2104| | dump_maybe_empty(ids_v[value.index()], b, ix); 2105| | if constexpr (N == 0) { 2106| | dump('"', b, ix); 2107| | } 2108| | else { 2109| | dump("\",\n", b, ix); 2110| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| | } 2112| | } 2113| | } 2114| | else { 2115| | using id_type = std::decay_t[value.index()])>; 2116| | 2117| | dump("{\"", b, ix); 2118| | dump_maybe_empty(tag_v, b, ix); 2119| | 2120| | if constexpr (std::integral) { 2121| | dump("\":", b, ix); 2122| | serialize::op(ids_v[value.index()], ctx, b, ix); 2123| | if constexpr (N > 0) { 2124| | dump(',', b, ix); 2125| | } 2126| | } 2127| | else { 2128| | dump("\":\"", b, ix); 2129| | dump_maybe_empty(ids_v[value.index()], b, ix); 2130| | if constexpr (N == 0) { 2131| | dump('"', b, ix); 2132| | } 2133| | else { 2134| | dump("\",", b, ix); 2135| | } 2136| | } 2137| | } 2138| | if constexpr (is_memory_object) { 2139| | if (!val) [[unlikely]] { 2140| | ctx.error = error_code::invalid_variant_object; 2141| | return; 2142| | } 2143| | to>::template op()>(*val, ctx, b, ix); 2144| | } 2145| | else { 2146| | to::template op()>(val, ctx, b, ix); 2147| | } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| | if constexpr (Opts.skip_null_members) { 2150| | if (b[ix - 1] == ',') { 2151| | --ix; 2152| | } 2153| | } 2154| | 2155| | if constexpr (Opts.prettify) { 2156| | ctx.depth -= check_indentation_width(Opts); 2157| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| | return; 2159| | } 2160| | std::memcpy(&b[ix], "\n", 1); 2161| | ++ix; 2162| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| | ix += ctx.depth; 2164| | std::memcpy(&b[ix], "}", 1); 2165| | ++ix; 2166| | } 2167| | else { 2168| | dump('}', b, ix); 2169| | } 2170| | } 2171| 8.11k| else { 2172| 8.11k| to::template op(val, ctx, b, ix); 2173| 8.11k| } 2174| 8.11k| }, _ZN3glz2toILj10EDnE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERDnTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1841| 8.11k| { 1842| 8.11k| if constexpr (not check_write_unchecked(Opts)) { 1843| 8.11k| if (!ensure_space(ctx, b, ix + 4)) [[unlikely]] { ------------------ | Branch (1843:17): [True: 0, False: 8.11k] ------------------ 1844| 0| return; 1845| 0| } 1846| 8.11k| } 1847| | if constexpr (std::endian::native == std::endian::big) { 1848| | static constexpr char null_v[] = "null"; 1849| | std::memcpy(&b[ix], null_v, 4); 1850| | } 1851| 8.11k| else { 1852| 8.11k| static constexpr uint32_t null_v = 1819047278; 1853| 8.11k| std::memcpy(&b[ix], &null_v, 4); 1854| 8.11k| } 1855| 8.11k| ix += 4; 1856| 8.11k| } _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRS6_EEDaSS_: 1957| 5.38k| [&](auto&& val) { 1958| 5.38k| using V = std::decay_t; 1959| | 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| | custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| | if (missing_id(value, ctx)) { 1972| | return; 1973| | } 1974| | using id_type = std::decay_t[value.index()])>; 1975| | if constexpr (Opts.prettify) { 1976| | dump("{\n", b, ix); 1977| | ctx.depth += check_indentation_width(Opts); 1978| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| | dump('"', b, ix); 1980| | dump_maybe_empty(tag_v, b, ix); 1981| | if constexpr (std::integral) { 1982| | dump("\": ", b, ix); 1983| | serialize::op(ids_v[value.index()], ctx, b, ix); 1984| | } 1985| | else { 1986| | dump("\": \"", b, ix); 1987| | dump_maybe_empty(ids_v[value.index()], b, ix); 1988| | dump('"', b, ix); 1989| | } 1990| | const auto pos_after_tag = ix; 1991| | dump(",\n", b, ix); 1992| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| | const auto pos_body_start = ix; 1994| | to::template op()>(val, ctx, b, ix); 1995| | if (ix == pos_body_start) { 1996| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| | } 1998| | ctx.depth -= check_indentation_width(Opts); 1999| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| | return; 2001| | } 2002| | std::memcpy(&b[ix], "\n", 1); 2003| | ++ix; 2004| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| | ix += ctx.depth; 2006| | std::memcpy(&b[ix], "}", 1); 2007| | ++ix; 2008| | } 2009| | else { 2010| | dump("{\"", b, ix); 2011| | dump_maybe_empty(tag_v, b, ix); 2012| | if constexpr (std::integral) { 2013| | dump("\":", b, ix); 2014| | serialize::op(ids_v[value.index()], ctx, b, ix); 2015| | } 2016| | else { 2017| | dump("\":\"", b, ix); 2018| | dump_maybe_empty(ids_v[value.index()], b, ix); 2019| | dump('"', b, ix); 2020| | } 2021| | const auto pos_after_tag = ix; 2022| | dump(',', b, ix); 2023| | const auto pos_body_start = ix; 2024| | to::template op()>(val, ctx, b, ix); 2025| | if (ix == pos_body_start) { 2026| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| | } 2028| | dump('}', b, ix); 2029| | } 2030| | } 2031| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| | variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| | if (missing_id(value, ctx)) { 2036| | return; 2037| | } 2038| | if constexpr (Opts.prettify) { 2039| | dump("{\n", b, ix); 2040| | ctx.depth += check_indentation_width(Opts); 2041| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| | dump('"', b, ix); 2043| | dump_maybe_empty(tag_v, b, ix); 2044| | dump("\": ", b, ix); 2045| | write_id(value, ctx, b, ix); 2046| | ctx.depth -= check_indentation_width(Opts); 2047| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| | return; 2049| | } 2050| | std::memcpy(&b[ix], "\n", 1); 2051| | ++ix; 2052| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| | ix += ctx.depth; 2054| | std::memcpy(&b[ix], "}", 1); 2055| | ++ix; 2056| | } 2057| | else { 2058| | dump("{\"", b, ix); 2059| | dump_maybe_empty(tag_v, b, ix); 2060| | dump("\":", b, ix); 2061| | write_id(value, ctx, b, ix); 2062| | dump('}', b, ix); 2063| | } 2064| | } 2065| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| | (glaze_object_t || reflectable || is_memory_object) && 2067| | (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| | if (missing_id(value, ctx)) { 2073| | return; 2074| | } 2075| | constexpr auto N = []() { 2076| | if constexpr (is_memory_object) { 2077| | return reflect>::size; 2078| | } 2079| | else { 2080| | return reflect::size; 2081| | } 2082| | }(); 2083| | 2084| | // must first write out type 2085| | if constexpr (Opts.prettify) { 2086| | dump("{\n", b, ix); 2087| | ctx.depth += check_indentation_width(Opts); 2088| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| | dump('"', b, ix); 2090| | dump_maybe_empty(tag_v, b, ix); 2091| | 2092| | using id_type = std::decay_t[value.index()])>; 2093| | 2094| | if constexpr (std::integral) { 2095| | dump("\": ", b, ix); 2096| | serialize::op(ids_v[value.index()], ctx, b, ix); 2097| | if constexpr (N > 0) { 2098| | dump(",\n", b, ix); 2099| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| | } 2101| | } 2102| | else { 2103| | dump("\": \"", b, ix); 2104| | dump_maybe_empty(ids_v[value.index()], b, ix); 2105| | if constexpr (N == 0) { 2106| | dump('"', b, ix); 2107| | } 2108| | else { 2109| | dump("\",\n", b, ix); 2110| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| | } 2112| | } 2113| | } 2114| | else { 2115| | using id_type = std::decay_t[value.index()])>; 2116| | 2117| | dump("{\"", b, ix); 2118| | dump_maybe_empty(tag_v, b, ix); 2119| | 2120| | if constexpr (std::integral) { 2121| | dump("\":", b, ix); 2122| | serialize::op(ids_v[value.index()], ctx, b, ix); 2123| | if constexpr (N > 0) { 2124| | dump(',', b, ix); 2125| | } 2126| | } 2127| | else { 2128| | dump("\":\"", b, ix); 2129| | dump_maybe_empty(ids_v[value.index()], b, ix); 2130| | if constexpr (N == 0) { 2131| | dump('"', b, ix); 2132| | } 2133| | else { 2134| | dump("\",", b, ix); 2135| | } 2136| | } 2137| | } 2138| | if constexpr (is_memory_object) { 2139| | if (!val) [[unlikely]] { 2140| | ctx.error = error_code::invalid_variant_object; 2141| | return; 2142| | } 2143| | to>::template op()>(*val, ctx, b, ix); 2144| | } 2145| | else { 2146| | to::template op()>(val, ctx, b, ix); 2147| | } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| | if constexpr (Opts.skip_null_members) { 2150| | if (b[ix - 1] == ',') { 2151| | --ix; 2152| | } 2153| | } 2154| | 2155| | if constexpr (Opts.prettify) { 2156| | ctx.depth -= check_indentation_width(Opts); 2157| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| | return; 2159| | } 2160| | std::memcpy(&b[ix], "\n", 1); 2161| | ++ix; 2162| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| | ix += ctx.depth; 2164| | std::memcpy(&b[ix], "}", 1); 2165| | ++ix; 2166| | } 2167| | else { 2168| | dump('}', b, ix); 2169| | } 2170| | } 2171| 5.38k| else { 2172| 5.38k| to::template op(val, ctx, b, ix); 2173| 5.38k| } 2174| 5.38k| }, _ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 5.38k| { 846| | if constexpr (check_string_as_number(Opts)) { 847| | const sv str = [&]() -> const sv { 848| | if constexpr (array_char_t) { 849| | const auto* start = value.data(); 850| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 851| | return sv{start, end ? size_t(end - start) : value.size()}; 852| | } 853| | else if constexpr (u8str_t) { 854| | return sv{reinterpret_cast(value.data()), value.size()}; 855| | } 856| | else { 857| | return str_view(value); 858| | } 859| | }(); 860| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 861| | return; 862| | } 863| | dump_maybe_empty(str, b, ix); 864| | } 865| | else if constexpr (char_t) { 866| | if constexpr (check_unquoted(Opts)) { 867| | dump(value, b, ix); 868| | } 869| | else { 870| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 871| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 872| | return; 873| | } 874| | 875| | std::memcpy(&b[ix], "\"", 1); 876| | ++ix; 877| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 878| | std::memcpy(&b[ix], &escaped, 2); 879| | ix += 2; 880| | } 881| | else if (value == '\0') { 882| | // null character treated as empty string 883| | } 884| | else if constexpr (check_escape_control_characters(Opts)) { 885| | if (uint8_t(value) < 0x20) { 886| | // Write as \uXXXX format 887| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 888| | constexpr char hex_digits[] = "0123456789ABCDEF"; 889| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 890| | unicode_escape[5] = hex_digits[value & 0xF]; 891| | std::memcpy(&b[ix], unicode_escape, 6); 892| | ix += 6; 893| | } 894| | else { 895| | std::memcpy(&b[ix], &value, 1); 896| | ++ix; 897| | } 898| | } 899| | else { 900| | if constexpr (check_reject_control_characters(Opts)) { 901| | if (uint8_t(value) < 0x20) [[unlikely]] { 902| | ctx.error = error_code::invalid_control_character; 903| | } 904| | } 905| | std::memcpy(&b[ix], &value, 1); 906| | ++ix; 907| | } 908| | std::memcpy(&b[ix], "\"", 1); 909| | ++ix; 910| | } 911| | } 912| 5.38k| else { 913| | if constexpr (check_raw_string(Opts)) { 914| | const sv str = [&]() -> const sv { 915| | if constexpr (u8str_t) { 916| | return sv{reinterpret_cast(value.data()), value.size()}; 917| | } 918| | else { 919| | return str_view(value); 920| | } 921| | }(); 922| | 923| | // We need space for quotes and the string length: 2 + n. 924| | // Use +8 for extra buffer 925| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 926| | return; 927| | } 928| | // now we don't have to check writing 929| | 930| | if constexpr (not check_unquoted(Opts)) { 931| | std::memcpy(&b[ix], "\"", 1); 932| | ++ix; 933| | } 934| | if (str.size()) [[likely]] { 935| | const auto n = str.size(); 936| | std::memcpy(&b[ix], str.data(), n); 937| | ix += n; 938| | } 939| | if constexpr (not check_unquoted(Opts)) { 940| | std::memcpy(&b[ix], "\"", 1); 941| | ++ix; 942| | } 943| | } 944| 5.38k| else { 945| 5.38k| const sv str = [&]() -> const sv { 946| 5.38k| if constexpr (array_char_t) { 947| 5.38k| return sv{value.data(), value.size()}; 948| 5.38k| } 949| 5.38k| else if constexpr (u8str_t) { 950| 5.38k| return sv{reinterpret_cast(value.data()), value.size()}; 951| 5.38k| } 952| 5.38k| else { 953| 5.38k| return str_view(value); 954| 5.38k| } 955| 5.38k| }(); 956| 5.38k| const auto n = str.size(); 957| | 958| | // In the case n == 0 we need two characters for quotes. 959| | // For each individual character we need room for two characters to handle escapes. 960| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 961| | if constexpr (check_escape_control_characters(Opts)) { 962| | if constexpr (has_bounded_capacity) { 963| | // 6 bytes per character is a ceiling only a string of nothing but control 964| | // characters reaches. A resizable buffer merely over-allocates against it, 965| | // but a fixed buffer has nowhere to grow, so the ceiling would reject output 966| | // that fits. Measuring the string answers exactly, at the cost of a pass over 967| | // it, so bracket the measurement between two O(1) bounds and only pay it when 968| | // the answer is still in doubt: the ceiling fitting means yes, and the floor 969| | // of one byte per character not fitting means no. 970| | const size_t capacity = buffer_traits>::capacity(b); 971| | size_t required = ix + 10 + 6 * n; 972| | if (required > capacity) [[unlikely]] { 973| | required = ix + 10 + n; 974| | if (required <= capacity) { 975| | required = ix + 10 + detail::escaped_string_size(str); 976| | } 977| | } 978| | if (!ensure_space(ctx, b, required)) [[unlikely]] { 979| | return; 980| | } 981| | } 982| | // We need 2 + 6 * n characters in the worst case (all control chars) 983| | else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 984| | return; 985| | } 986| | } 987| 5.38k| else { 988| | // Using the original sizing 989| 5.38k| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 5.38k] ------------------ 990| 0| return; 991| 0| } 992| 5.38k| } 993| | // now we don't have to check writing 994| | 995| | if constexpr (check_unquoted(Opts)) { 996| | if (n) { 997| | std::memcpy(&b[ix], str.data(), n); 998| | ix += n; 999| | } 1000| | } 1001| 5.38k| else { 1002| 5.38k| std::memcpy(&b[ix], "\"", 1); 1003| 5.38k| ++ix; 1004| | 1005| 5.38k| const auto* c = str.data(); 1006| 5.38k| const auto* const e = c + n; 1007| 5.38k| const auto start = &b[ix]; 1008| 5.38k| auto data = start; 1009| | 1010| | // By default we don't escape control characters for performance. Invalid JSON characters 1011| | // result in null characters in the output, making the JSON invalid — these would then be 1012| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 1013| | // control characters (0x00–0x1F) as \uXXXX sequences. 1014| | 1015| | // Escape handler: writes the escaped form of *c into data, advances both pointers 1016| 5.38k| auto write_escape = [&]() { 1017| 5.38k| if constexpr (check_escape_control_characters(Opts)) { 1018| 5.38k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 5.38k| std::memcpy(data, &escaped, 2); 1020| 5.38k| data += 2; 1021| 5.38k| } 1022| 5.38k| else { 1023| 5.38k| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 5.38k| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 5.38k| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 5.38k| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 5.38k| std::memcpy(data, unicode_escape, 6); 1028| 5.38k| data += 6; 1029| 5.38k| } 1030| 5.38k| } 1031| 5.38k| else { 1032| 5.38k| if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| 5.38k| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 5.38k| ctx.error = error_code::invalid_control_character; 1040| 5.38k| } 1041| 5.38k| } 1042| 5.38k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 5.38k| data += 2; 1044| 5.38k| } 1045| 5.38k| ++c; 1046| 5.38k| }; 1047| | 1048| | // Adding a helper here means adding a branch to string_escape_simd() in 1049| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 1050| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 1051| |#if defined(GLZ_USE_AVX2) 1052| | detail::avx2_string_escape(c, e, data, n, write_escape); 1053| |#endif 1054| 5.38k|#if defined(GLZ_USE_SSE2) 1055| 5.38k| detail::sse2_string_escape(c, e, data, n, write_escape); 1056| |#elif defined(GLZ_USE_NEON) 1057| | detail::neon_string_escape(c, e, data, n, write_escape); 1058| |#endif 1059| | 1060| | // SWAR: 8 bytes at a time 1061| 5.38k| if (n > 7) { ------------------ | Branch (1061:23): [True: 3.87k, False: 1.51k] ------------------ 1062| 14.9k| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 11.1k, False: 3.87k] ------------------ 1063| 11.1k| std::memcpy(data, c, 8); 1064| 11.1k| uint64_t swar; 1065| 11.1k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 11.1k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 11.1k| const uint64_t lo7 = swar & lo7_mask; 1072| 11.1k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 11.1k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 11.1k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 11.1k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 11.1k| next &= repeat_byte8(0b10000000); 1078| 11.1k| if (next == 0) { ------------------ | Branch (1078:29): [True: 1.40k, False: 9.71k] ------------------ 1079| 1.40k| data += 8; 1080| 1.40k| c += 8; 1081| 1.40k| continue; 1082| 1.40k| } 1083| | 1084| 9.71k| const auto length = (countr_zero(next) >> 3); 1085| 9.71k| c += length; 1086| 9.71k| data += length; 1087| 9.71k| write_escape(); 1088| 9.71k| } 1089| 3.87k| } 1090| | 1091| | // Scalar tail 1092| 26.6k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 21.2k, False: 5.38k] ------------------ 1093| 21.2k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 1.57k, False: 19.6k] ------------------ 1094| 1.57k| std::memcpy(data, &escaped, 2); 1095| 1.57k| data += 2; 1096| 1.57k| } 1097| | else if constexpr (check_escape_control_characters(Opts)) { 1098| | if (uint8_t(*c) < 0x20) { 1099| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1100| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1101| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1102| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1103| | std::memcpy(data, unicode_escape, 6); 1104| | data += 6; 1105| | } 1106| | else { 1107| | std::memcpy(data, c, 1); 1108| | ++data; 1109| | } 1110| | } 1111| 19.6k| else { 1112| | if constexpr (check_reject_control_characters(Opts)) { 1113| | if (uint8_t(*c) < 0x20) [[unlikely]] { 1114| | ctx.error = error_code::invalid_control_character; 1115| | } 1116| | } 1117| 19.6k| std::memcpy(data, c, 1); 1118| 19.6k| ++data; 1119| 19.6k| } 1120| 21.2k| } 1121| | 1122| 5.38k| ix += size_t(data - start); 1123| | 1124| 5.38k| std::memcpy(&b[ix], "\"", 1); 1125| 5.38k| ++ix; 1126| 5.38k| } 1127| 5.38k| } 1128| 5.38k| } 1129| 5.38k| } _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 5.38k| const sv str = [&]() -> const sv { 946| | if constexpr (array_char_t) { 947| | return sv{value.data(), value.size()}; 948| | } 949| | else if constexpr (u8str_t) { 950| | return sv{reinterpret_cast(value.data()), value.size()}; 951| | } 952| 5.38k| else { 953| 5.38k| return str_view(value); 954| 5.38k| } 955| 5.38k| }(); _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 28.0M| auto write_escape = [&]() { 1017| | if constexpr (check_escape_control_characters(Opts)) { 1018| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| | std::memcpy(data, &escaped, 2); 1020| | data += 2; 1021| | } 1022| | else { 1023| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| | std::memcpy(data, unicode_escape, 6); 1028| | data += 6; 1029| | } 1030| | } 1031| 28.0M| else { 1032| | if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| | if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| | ctx.error = error_code::invalid_control_character; 1040| | } 1041| | } 1042| 28.0M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 28.0M| data += 2; 1044| 28.0M| } 1045| 28.0M| ++c; 1046| 28.0M| }; _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRlEEDaSS_: 1957| 30.9k| [&](auto&& val) { 1958| 30.9k| using V = std::decay_t; 1959| | 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| | custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| | if (missing_id(value, ctx)) { 1972| | return; 1973| | } 1974| | using id_type = std::decay_t[value.index()])>; 1975| | if constexpr (Opts.prettify) { 1976| | dump("{\n", b, ix); 1977| | ctx.depth += check_indentation_width(Opts); 1978| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| | dump('"', b, ix); 1980| | dump_maybe_empty(tag_v, b, ix); 1981| | if constexpr (std::integral) { 1982| | dump("\": ", b, ix); 1983| | serialize::op(ids_v[value.index()], ctx, b, ix); 1984| | } 1985| | else { 1986| | dump("\": \"", b, ix); 1987| | dump_maybe_empty(ids_v[value.index()], b, ix); 1988| | dump('"', b, ix); 1989| | } 1990| | const auto pos_after_tag = ix; 1991| | dump(",\n", b, ix); 1992| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| | const auto pos_body_start = ix; 1994| | to::template op()>(val, ctx, b, ix); 1995| | if (ix == pos_body_start) { 1996| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| | } 1998| | ctx.depth -= check_indentation_width(Opts); 1999| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| | return; 2001| | } 2002| | std::memcpy(&b[ix], "\n", 1); 2003| | ++ix; 2004| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| | ix += ctx.depth; 2006| | std::memcpy(&b[ix], "}", 1); 2007| | ++ix; 2008| | } 2009| | else { 2010| | dump("{\"", b, ix); 2011| | dump_maybe_empty(tag_v, b, ix); 2012| | if constexpr (std::integral) { 2013| | dump("\":", b, ix); 2014| | serialize::op(ids_v[value.index()], ctx, b, ix); 2015| | } 2016| | else { 2017| | dump("\":\"", b, ix); 2018| | dump_maybe_empty(ids_v[value.index()], b, ix); 2019| | dump('"', b, ix); 2020| | } 2021| | const auto pos_after_tag = ix; 2022| | dump(',', b, ix); 2023| | const auto pos_body_start = ix; 2024| | to::template op()>(val, ctx, b, ix); 2025| | if (ix == pos_body_start) { 2026| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| | } 2028| | dump('}', b, ix); 2029| | } 2030| | } 2031| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| | variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| | if (missing_id(value, ctx)) { 2036| | return; 2037| | } 2038| | if constexpr (Opts.prettify) { 2039| | dump("{\n", b, ix); 2040| | ctx.depth += check_indentation_width(Opts); 2041| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| | dump('"', b, ix); 2043| | dump_maybe_empty(tag_v, b, ix); 2044| | dump("\": ", b, ix); 2045| | write_id(value, ctx, b, ix); 2046| | ctx.depth -= check_indentation_width(Opts); 2047| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| | return; 2049| | } 2050| | std::memcpy(&b[ix], "\n", 1); 2051| | ++ix; 2052| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| | ix += ctx.depth; 2054| | std::memcpy(&b[ix], "}", 1); 2055| | ++ix; 2056| | } 2057| | else { 2058| | dump("{\"", b, ix); 2059| | dump_maybe_empty(tag_v, b, ix); 2060| | dump("\":", b, ix); 2061| | write_id(value, ctx, b, ix); 2062| | dump('}', b, ix); 2063| | } 2064| | } 2065| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| | (glaze_object_t || reflectable || is_memory_object) && 2067| | (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| | if (missing_id(value, ctx)) { 2073| | return; 2074| | } 2075| | constexpr auto N = []() { 2076| | if constexpr (is_memory_object) { 2077| | return reflect>::size; 2078| | } 2079| | else { 2080| | return reflect::size; 2081| | } 2082| | }(); 2083| | 2084| | // must first write out type 2085| | if constexpr (Opts.prettify) { 2086| | dump("{\n", b, ix); 2087| | ctx.depth += check_indentation_width(Opts); 2088| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| | dump('"', b, ix); 2090| | dump_maybe_empty(tag_v, b, ix); 2091| | 2092| | using id_type = std::decay_t[value.index()])>; 2093| | 2094| | if constexpr (std::integral) { 2095| | dump("\": ", b, ix); 2096| | serialize::op(ids_v[value.index()], ctx, b, ix); 2097| | if constexpr (N > 0) { 2098| | dump(",\n", b, ix); 2099| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| | } 2101| | } 2102| | else { 2103| | dump("\": \"", b, ix); 2104| | dump_maybe_empty(ids_v[value.index()], b, ix); 2105| | if constexpr (N == 0) { 2106| | dump('"', b, ix); 2107| | } 2108| | else { 2109| | dump("\",\n", b, ix); 2110| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| | } 2112| | } 2113| | } 2114| | else { 2115| | using id_type = std::decay_t[value.index()])>; 2116| | 2117| | dump("{\"", b, ix); 2118| | dump_maybe_empty(tag_v, b, ix); 2119| | 2120| | if constexpr (std::integral) { 2121| | dump("\":", b, ix); 2122| | serialize::op(ids_v[value.index()], ctx, b, ix); 2123| | if constexpr (N > 0) { 2124| | dump(',', b, ix); 2125| | } 2126| | } 2127| | else { 2128| | dump("\":\"", b, ix); 2129| | dump_maybe_empty(ids_v[value.index()], b, ix); 2130| | if constexpr (N == 0) { 2131| | dump('"', b, ix); 2132| | } 2133| | else { 2134| | dump("\",", b, ix); 2135| | } 2136| | } 2137| | } 2138| | if constexpr (is_memory_object) { 2139| | if (!val) [[unlikely]] { 2140| | ctx.error = error_code::invalid_variant_object; 2141| | return; 2142| | } 2143| | to>::template op()>(*val, ctx, b, ix); 2144| | } 2145| | else { 2146| | to::template op()>(val, ctx, b, ix); 2147| | } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| | if constexpr (Opts.skip_null_members) { 2150| | if (b[ix - 1] == ',') { 2151| | --ix; 2152| | } 2153| | } 2154| | 2155| | if constexpr (Opts.prettify) { 2156| | ctx.depth -= check_indentation_width(Opts); 2157| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| | return; 2159| | } 2160| | std::memcpy(&b[ix], "\n", 1); 2161| | ++ix; 2162| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| | ix += ctx.depth; 2164| | std::memcpy(&b[ix], "}", 1); 2165| | ++ix; 2166| | } 2167| | else { 2168| | dump('}', b, ix); 2169| | } 2170| | } 2171| 30.9k| else { 2172| 30.9k| to::template op(val, ctx, b, ix); 2173| 30.9k| } 2174| 30.9k| }, _ZN3glz2toILj10ElE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 30.9k| { 815| 30.9k| if constexpr (not check_write_unchecked(Opts)) { 816| 30.9k| static_assert(required_padding()); 817| 30.9k| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 30.9k] ------------------ 818| 0| return; 819| 0| } 820| 30.9k| } 821| | 822| 30.9k| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 30.9k| else { 832| 30.9k| write_chars::op(value, ctx, b, ix); 833| 30.9k| } 834| 30.9k| } _ZN3glz16required_paddingIlEEmv: 538| 30.9k| { 539| 30.9k| constexpr auto value = []() -> size_t { 540| 30.9k| if constexpr (boolean_like) { 541| 30.9k| return 8; 542| 30.9k| } 543| 30.9k| else if constexpr (num_t) { 544| 30.9k| if constexpr (std::floating_point) { 545| 30.9k| if constexpr (sizeof(T) > 8) { 546| 30.9k| return 64; 547| 30.9k| } 548| 30.9k| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 30.9k| return zmij::double_buffer_size + 4; 551| 30.9k| } 552| 30.9k| else { 553| 30.9k| return zmij::float_buffer_size + 4; 554| 30.9k| } 555| 30.9k| } 556| 30.9k| else if constexpr (sizeof(T) > 4) { 557| 30.9k| return 24; 558| 30.9k| } 559| 30.9k| else if constexpr (sizeof(T) > 2) { 560| 30.9k| return 16; 561| 30.9k| } 562| 30.9k| else { 563| 30.9k| return 8; 564| 30.9k| } 565| 30.9k| } 566| 30.9k| else if constexpr (nullable_like) { 567| 30.9k| if constexpr (has_value_type) { 568| 30.9k| return required_padding(); 569| 30.9k| } 570| 30.9k| else if constexpr (has_element_type) { 571| 30.9k| return required_padding(); 572| 30.9k| } 573| 30.9k| else { 574| 30.9k| return 0; 575| 30.9k| } 576| 30.9k| } 577| 30.9k| else if constexpr (always_null_t) { 578| 30.9k| return 8; 579| 30.9k| } 580| 30.9k| else { 581| 30.9k| return 0; 582| 30.9k| } 583| 30.9k| }(); 584| | 585| | if constexpr (value >= (write_padding_bytes - 16)) { 586| | // we always require 16 bytes available from write_padding_bytes 587| | // for opening and closing characters 588| | return 0; 589| | } 590| 30.9k| return value; 591| 30.9k| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 173| { 815| | if constexpr (not check_write_unchecked(Opts)) { 816| | static_assert(required_padding()); 817| | if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { 818| | return; 819| | } 820| | } 821| | 822| 173| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 173| else { 832| 173| write_chars::op(value, ctx, b, ix); 833| 173| } 834| 173| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 370| { 815| 370| if constexpr (not check_write_unchecked(Opts)) { 816| 370| static_assert(required_padding()); 817| 370| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 370] ------------------ 818| 0| return; 819| 0| } 820| 370| } 821| | 822| 370| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 370| else { 832| 370| write_chars::op(value, ctx, b, ix); 833| 370| } 834| 370| } _ZN3glz16required_paddingIiEEmv: 538| 681| { 539| 681| constexpr auto value = []() -> size_t { 540| 681| if constexpr (boolean_like) { 541| 681| return 8; 542| 681| } 543| 681| else if constexpr (num_t) { 544| 681| if constexpr (std::floating_point) { 545| 681| if constexpr (sizeof(T) > 8) { 546| 681| return 64; 547| 681| } 548| 681| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 681| return zmij::double_buffer_size + 4; 551| 681| } 552| 681| else { 553| 681| return zmij::float_buffer_size + 4; 554| 681| } 555| 681| } 556| 681| else if constexpr (sizeof(T) > 4) { 557| 681| return 24; 558| 681| } 559| 681| else if constexpr (sizeof(T) > 2) { 560| 681| return 16; 561| 681| } 562| 681| else { 563| 681| return 8; 564| 681| } 565| 681| } 566| 681| else if constexpr (nullable_like) { 567| 681| if constexpr (has_value_type) { 568| 681| return required_padding(); 569| 681| } 570| 681| else if constexpr (has_element_type) { 571| 681| return required_padding(); 572| 681| } 573| 681| else { 574| 681| return 0; 575| 681| } 576| 681| } 577| 681| else if constexpr (always_null_t) { 578| 681| return 8; 579| 681| } 580| 681| else { 581| 681| return 0; 582| 681| } 583| 681| }(); 584| | 585| | if constexpr (value >= (write_padding_bytes - 16)) { 586| | // we always require 16 bytes available from write_padding_bytes 587| | // for opening and closing characters 588| | return 0; 589| | } 590| 681| return value; 591| 681| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 311| { 815| 311| if constexpr (not check_write_unchecked(Opts)) { 816| 311| static_assert(required_padding()); 817| 311| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 311] ------------------ 818| 0| return; 819| 0| } 820| 311| } 821| | 822| 311| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 311| else { 832| 311| write_chars::op(value, ctx, b, ix); 833| 311| } 834| 311| } _ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2465| 158| { 2466| 158| using ValueType = std::decay_t; 2467| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2468| | constexpr auto& writer = meta_unknown_write_v; 2469| | 2470| | using WriterType = meta_unknown_write_t; 2471| | if constexpr (std::is_member_object_pointer_v) { 2472| | decltype(auto) unknown_writer = value.*writer; 2473| | if (unknown_writer.size() > 0) { 2474| | // TODO: This intermediate is added to get GCC 14 to build 2475| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2476| | serialize::op()>(std::move(merged), ctx, b, ix); 2477| | } 2478| | else { 2479| | serialize::op()>(value, ctx, b, ix); 2480| | } 2481| | } 2482| | else if constexpr (std::is_member_function_pointer_v) { 2483| | decltype(auto) unknown_writer = (value.*writer)(); 2484| | if (unknown_writer.size() > 0) { 2485| | // TODO: This intermediate is added to get GCC 14 to build 2486| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2487| | serialize::op()>(std::move(merged), ctx, b, ix); 2488| | } 2489| | else { 2490| | serialize::op()>(value, ctx, b, ix); 2491| | } 2492| | } 2493| | else { 2494| | static_assert(false_v, "unknown_write type not handled"); 2495| | } 2496| | } 2497| 158| else { 2498| | // handles glaze_object_t without extra unknown fields 2499| 158| static constexpr auto Opts = 2500| 158| disable_write_unknown_off()>()>(); 2501| | 2502| 158| if constexpr (not check_opening_handled(Options)) { 2503| | if constexpr (Options.prettify) { 2504| | ctx.depth += check_indentation_width(Options); 2505| | if constexpr (not check_write_unchecked(Options)) { 2506| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2507| | return; 2508| | } 2509| | } 2510| | std::memcpy(&b[ix], "{\n", 2); 2511| | ix += 2; 2512| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2513| | ix += ctx.depth; 2514| | } 2515| 158| else { 2516| 158| if constexpr (not check_write_unchecked(Options)) { 2517| 158| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2517:26): [True: 0, False: 158] ------------------ 2518| 0| return; 2519| 0| } 2520| 158| } 2521| 158| dump('{', b, ix); 2522| 158| } 2523| 158| } 2524| | 2525| 0| static constexpr auto N = reflect::size; 2526| | 2527| 158| decltype(auto) t = [&]() -> decltype(auto) { 2528| 158| if constexpr (reflectable) { 2529| 158| return to_tie(value); 2530| 158| } 2531| 158| else { 2532| 158| return nullptr; 2533| 158| } 2534| 158| }(); 2535| | 2536| 158| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2537| | if constexpr (maybe_skipped) { 2538| | bool first = true; 2539| | for_each([&]() { 2540| | using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| | else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| | if (is_glaze_value_field_null(value, t)) return; 2598| | } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| | else { 2618| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2619| | return; 2620| | } 2621| | } 2622| | 2623| | if (first) { 2624| | first = false; 2625| | } 2626| | else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| | else { 2635| | std::memcpy(&b[ix], ",", 1); 2636| | ++ix; 2637| | } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| | } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| | static constexpr auto quoted_key = quoted_key_v; 2646| | static constexpr auto n = quoted_key.size(); 2647| | std::memcpy(&b[ix], quoted_key.data(), n); 2648| | ix += n; 2649| | 2650| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2651| | if constexpr (reflectable) { 2652| | to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| | } 2659| | }); 2660| | } 2661| 158| else { 2662| 158| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2662:57): [Folded, False: 158] ------------------ 2663| 158| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2664| 158| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2664:23): [True: 0, False: 158] ------------------ 2665| 0| return; 2666| 0| } 2667| 158| } 2668| | 2669| 158| for_each([&]() { 2670| 158| if constexpr (write_can_error()) { 2671| 158| if (bool(ctx.error)) [[unlikely]] { 2672| 158| return; 2673| 158| } 2674| 158| } 2675| 158| if constexpr (not fixed_max_size) { 2676| 158| if constexpr (Opts.prettify) { 2677| 158| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| 158| return; 2679| 158| } 2680| 158| } 2681| 158| else { 2682| 158| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| 158| return; 2684| 158| } 2685| 158| } 2686| 158| } 2687| | 2688| 158| if constexpr (I != 0 && Opts.prettify) { 2689| 158| std::memcpy(&b[ix], ",\n", 2); 2690| 158| ix += 2; 2691| 158| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| 158| ix += ctx.depth; 2693| 158| } 2694| | 2695| 158| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 158| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| 158| if constexpr (always_null_t) { 2700| 158| if constexpr (I == 0 || Opts.prettify) { 2701| 158| static constexpr auto quoted_key = join_v, chars<"null">>; 2702| 158| static constexpr auto n = quoted_key.size(); 2703| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2704| 158| ix += n; 2705| 158| } 2706| 158| else { 2707| 158| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| 158| static constexpr auto n = quoted_key.size(); 2709| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2710| 158| ix += n; 2711| 158| } 2712| 158| } 2713| 158| else { 2714| 158| if constexpr (I == 0 || Opts.prettify) { 2715| 158| static constexpr auto quoted_key = quoted_key_v; 2716| 158| static constexpr auto n = quoted_key.size(); 2717| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 158| ix += n; 2719| 158| } 2720| 158| else { 2721| 158| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 158| static constexpr auto n = quoted_key.size(); 2723| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 158| ix += n; 2725| 158| } 2726| | 2727| 158| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2728| 158| if constexpr (reflectable) { 2729| 158| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| 158| } 2731| 158| else { 2732| 158| to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| 158| ix); 2734| 158| } 2735| 158| } 2736| 158| }); 2737| 158| } 2738| | 2739| | // Options is required here, because it must be the top level 2740| 158| if constexpr (not check_closing_handled(Options)) { 2741| | if constexpr (Options.prettify) { 2742| | ctx.depth -= check_indentation_width(Options); 2743| | if constexpr (not check_write_unchecked(Options)) { 2744| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2745| | return; 2746| | } 2747| | } 2748| | std::memcpy(&b[ix], "\n", 1); 2749| | ++ix; 2750| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2751| | ix += ctx.depth; 2752| | std::memcpy(&b[ix], "}", 1); 2753| | ++ix; 2754| | } 2755| 158| else { 2756| 158| dump || check_write_unchecked(Options))>('}', b, ix); 2757| 158| } 2758| 158| } 2759| 158| } 2760| 158| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2527| 158| decltype(auto) t = [&]() -> decltype(auto) { 2528| 158| if constexpr (reflectable) { 2529| 158| return to_tie(value); 2530| | } 2531| | else { 2532| | return nullptr; 2533| | } 2534| 158| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2669| 158| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| | if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| | else { 2682| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| | return; 2684| | } 2685| | } 2686| | } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 158| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 158| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 158| else { 2714| 158| if constexpr (I == 0 || Opts.prettify) { 2715| 158| static constexpr auto quoted_key = quoted_key_v; 2716| 158| static constexpr auto n = quoted_key.size(); 2717| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 158| ix += n; 2719| | } 2720| | else { 2721| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| | static constexpr auto n = quoted_key.size(); 2723| | std::memcpy(&b[ix], quoted_key.data(), n); 2724| | ix += n; 2725| | } 2726| | 2727| 158| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [True: 0, Folded] ------------------ 2728| 158| if constexpr (reflectable) { 2729| 158| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 158| } 2736| 158| }); _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 910| { 815| | if constexpr (not check_write_unchecked(Opts)) { 816| | static_assert(required_padding()); 817| | if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { 818| | return; 819| | } 820| | } 821| | 822| 910| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 910| else { 832| 910| write_chars::op(value, ctx, b, ix); 833| 910| } 834| 910| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2669| 158| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| | if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| | else { 2682| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| | return; 2684| | } 2685| | } 2686| | } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 158| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 158| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 158| else { 2714| | if constexpr (I == 0 || Opts.prettify) { 2715| | static constexpr auto quoted_key = quoted_key_v; 2716| | static constexpr auto n = quoted_key.size(); 2717| | std::memcpy(&b[ix], quoted_key.data(), n); 2718| | ix += n; 2719| | } 2720| 158| else { 2721| 158| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 158| static constexpr auto n = quoted_key.size(); 2723| 158| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 158| ix += n; 2725| 158| } 2726| | 2727| 158| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [True: 0, Folded] ------------------ 2728| 158| if constexpr (reflectable) { 2729| 158| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 158| } 2736| 158| }); _ZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2465| 50| { 2466| 50| using ValueType = std::decay_t; 2467| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2468| | constexpr auto& writer = meta_unknown_write_v; 2469| | 2470| | using WriterType = meta_unknown_write_t; 2471| | if constexpr (std::is_member_object_pointer_v) { 2472| | decltype(auto) unknown_writer = value.*writer; 2473| | if (unknown_writer.size() > 0) { 2474| | // TODO: This intermediate is added to get GCC 14 to build 2475| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2476| | serialize::op()>(std::move(merged), ctx, b, ix); 2477| | } 2478| | else { 2479| | serialize::op()>(value, ctx, b, ix); 2480| | } 2481| | } 2482| | else if constexpr (std::is_member_function_pointer_v) { 2483| | decltype(auto) unknown_writer = (value.*writer)(); 2484| | if (unknown_writer.size() > 0) { 2485| | // TODO: This intermediate is added to get GCC 14 to build 2486| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2487| | serialize::op()>(std::move(merged), ctx, b, ix); 2488| | } 2489| | else { 2490| | serialize::op()>(value, ctx, b, ix); 2491| | } 2492| | } 2493| | else { 2494| | static_assert(false_v, "unknown_write type not handled"); 2495| | } 2496| | } 2497| 50| else { 2498| | // handles glaze_object_t without extra unknown fields 2499| 50| static constexpr auto Opts = 2500| 50| disable_write_unknown_off()>()>(); 2501| | 2502| 50| if constexpr (not check_opening_handled(Options)) { 2503| | if constexpr (Options.prettify) { 2504| | ctx.depth += check_indentation_width(Options); 2505| | if constexpr (not check_write_unchecked(Options)) { 2506| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2507| | return; 2508| | } 2509| | } 2510| | std::memcpy(&b[ix], "{\n", 2); 2511| | ix += 2; 2512| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2513| | ix += ctx.depth; 2514| | } 2515| 50| else { 2516| 50| if constexpr (not check_write_unchecked(Options)) { 2517| 50| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2517:26): [True: 0, False: 50] ------------------ 2518| 0| return; 2519| 0| } 2520| 50| } 2521| 50| dump('{', b, ix); 2522| 50| } 2523| 50| } 2524| | 2525| 0| static constexpr auto N = reflect::size; 2526| | 2527| 50| decltype(auto) t = [&]() -> decltype(auto) { 2528| 50| if constexpr (reflectable) { 2529| 50| return to_tie(value); 2530| 50| } 2531| 50| else { 2532| 50| return nullptr; 2533| 50| } 2534| 50| }(); 2535| | 2536| 50| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2537| 50| if constexpr (maybe_skipped) { 2538| 50| bool first = true; 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| 50| if constexpr (skipped_by_meta || always_skipped || 2547| 50| (!write_function_pointers && is_any_function_ptr)) { 2548| 50| return; 2549| 50| } 2550| 50| else { 2551| 50| if constexpr (meta_has_skip_if) { 2552| 50| static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| 50| static constexpr meta_context mctx{.op = operation::serialize}; 2554| 50| decltype(auto) field_value = [&]() -> decltype(auto) { 2555| 50| if constexpr (reflectable) { 2556| 50| return get(t); 2557| 50| } 2558| 50| else { 2559| 50| return get_member(value, glz::get(reflect::values)); 2560| 50| } 2561| 50| }(); 2562| 50| if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| 50| } 2564| | 2565| 50| if constexpr (null_t && Opts.skip_null_members) { 2566| 50| if constexpr (always_null_t) 2567| 50| return; 2568| 50| else { 2569| 50| const auto is_null = [&]() { 2570| 50| decltype(auto) element = [&]() -> decltype(auto) { 2571| 50| if constexpr (reflectable) { 2572| 50| return get(t); 2573| 50| } 2574| 50| else { 2575| 50| return get(reflect::values); 2576| 50| } 2577| 50| }; 2578| | 2579| 50| if constexpr (nullable_wrapper) { 2580| 50| return !bool(element()(value).val); 2581| 50| } 2582| 50| else if constexpr (nullable_value_t) { 2583| 50| return !get_member(value, element()).has_value(); 2584| 50| } 2585| 50| else { 2586| 50| return !bool(get_member(value, element())); 2587| 50| } 2588| 50| }(); 2589| 50| if (is_null) return; 2590| 50| } 2591| 50| } 2592| 50| else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| 50| custom_getter_returns_nullable()) { 2594| 50| if (is_custom_field_null(value, t, ctx)) return; 2595| 50| } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| 50| if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| 50| decltype(auto) member = [&]() -> decltype(auto) { 2602| 50| if constexpr (reflectable) { 2603| 50| return get_member(value, get(t)); 2604| 50| } 2605| 50| else { 2606| 50| return get_member(value, get(reflect::values)); 2607| 50| } 2608| 50| }(); 2609| 50| if (is_default_value(member)) return; 2610| 50| } 2611| | 2612| 50| if constexpr (Opts.prettify) { 2613| 50| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| 50| return; 2615| 50| } 2616| 50| } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2619| 50| return; 2620| 50| } 2621| 50| } 2622| | 2623| 50| if (first) { 2624| 50| first = false; 2625| 50| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| 50| if constexpr (Opts.prettify) { 2629| 50| std::memcpy(&b[ix], ",\n", 2); 2630| 50| ix += 2; 2631| 50| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| 50| ix += ctx.depth; 2633| 50| } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| 50| if constexpr (is_output_streaming) { 2639| 50| flush_buffer(b, ix); 2640| 50| } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| 50| } 2654| 50| else { 2655| 50| to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| 50| ix); 2657| 50| } 2658| 50| } 2659| 50| }); 2660| | } 2661| | else { 2662| | static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; 2663| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2664| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2665| | return; 2666| | } 2667| | } 2668| | 2669| | for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| | if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| | else { 2682| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| | return; 2684| | } 2685| | } 2686| | } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| | using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| | else { 2714| | if constexpr (I == 0 || Opts.prettify) { 2715| | static constexpr auto quoted_key = quoted_key_v; 2716| | static constexpr auto n = quoted_key.size(); 2717| | std::memcpy(&b[ix], quoted_key.data(), n); 2718| | ix += n; 2719| | } 2720| | else { 2721| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| | static constexpr auto n = quoted_key.size(); 2723| | std::memcpy(&b[ix], quoted_key.data(), n); 2724| | ix += n; 2725| | } 2726| | 2727| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2728| | if constexpr (reflectable) { 2729| | to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| | } 2736| | }); 2737| | } 2738| | 2739| | // Options is required here, because it must be the top level 2740| 50| if constexpr (not check_closing_handled(Options)) { 2741| | if constexpr (Options.prettify) { 2742| | ctx.depth -= check_indentation_width(Options); 2743| | if constexpr (not check_write_unchecked(Options)) { 2744| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2745| | return; 2746| | } 2747| | } 2748| | std::memcpy(&b[ix], "\n", 1); 2749| | ++ix; 2750| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2751| | ix += ctx.depth; 2752| | std::memcpy(&b[ix], "}", 1); 2753| | ++ix; 2754| | } 2755| 50| else { 2756| 50| dump || check_write_unchecked(Options))>('}', b, ix); 2757| 50| } 2758| 50| } 2759| 50| } 2760| 50| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2527| 50| decltype(auto) t = [&]() -> decltype(auto) { 2528| 50| if constexpr (reflectable) { 2529| 50| return to_tie(value); 2530| | } 2531| | else { 2532| | return nullptr; 2533| | } 2534| 50| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 50, False: 0] ------------------ 2624| 50| first = false; 2625| 50| } 2626| 0| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 0| else { 2635| 0| std::memcpy(&b[ix], ",", 1); 2636| 0| ++ix; 2637| 0| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 0| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [True: 0, Folded] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 950| { 846| | if constexpr (check_string_as_number(Opts)) { 847| | const sv str = [&]() -> const sv { 848| | if constexpr (array_char_t) { 849| | const auto* start = value.data(); 850| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 851| | return sv{start, end ? size_t(end - start) : value.size()}; 852| | } 853| | else if constexpr (u8str_t) { 854| | return sv{reinterpret_cast(value.data()), value.size()}; 855| | } 856| | else { 857| | return str_view(value); 858| | } 859| | }(); 860| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 861| | return; 862| | } 863| | dump_maybe_empty(str, b, ix); 864| | } 865| | else if constexpr (char_t) { 866| | if constexpr (check_unquoted(Opts)) { 867| | dump(value, b, ix); 868| | } 869| | else { 870| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 871| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 872| | return; 873| | } 874| | 875| | std::memcpy(&b[ix], "\"", 1); 876| | ++ix; 877| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 878| | std::memcpy(&b[ix], &escaped, 2); 879| | ix += 2; 880| | } 881| | else if (value == '\0') { 882| | // null character treated as empty string 883| | } 884| | else if constexpr (check_escape_control_characters(Opts)) { 885| | if (uint8_t(value) < 0x20) { 886| | // Write as \uXXXX format 887| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 888| | constexpr char hex_digits[] = "0123456789ABCDEF"; 889| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 890| | unicode_escape[5] = hex_digits[value & 0xF]; 891| | std::memcpy(&b[ix], unicode_escape, 6); 892| | ix += 6; 893| | } 894| | else { 895| | std::memcpy(&b[ix], &value, 1); 896| | ++ix; 897| | } 898| | } 899| | else { 900| | if constexpr (check_reject_control_characters(Opts)) { 901| | if (uint8_t(value) < 0x20) [[unlikely]] { 902| | ctx.error = error_code::invalid_control_character; 903| | } 904| | } 905| | std::memcpy(&b[ix], &value, 1); 906| | ++ix; 907| | } 908| | std::memcpy(&b[ix], "\"", 1); 909| | ++ix; 910| | } 911| | } 912| 950| else { 913| | if constexpr (check_raw_string(Opts)) { 914| | const sv str = [&]() -> const sv { 915| | if constexpr (u8str_t) { 916| | return sv{reinterpret_cast(value.data()), value.size()}; 917| | } 918| | else { 919| | return str_view(value); 920| | } 921| | }(); 922| | 923| | // We need space for quotes and the string length: 2 + n. 924| | // Use +8 for extra buffer 925| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 926| | return; 927| | } 928| | // now we don't have to check writing 929| | 930| | if constexpr (not check_unquoted(Opts)) { 931| | std::memcpy(&b[ix], "\"", 1); 932| | ++ix; 933| | } 934| | if (str.size()) [[likely]] { 935| | const auto n = str.size(); 936| | std::memcpy(&b[ix], str.data(), n); 937| | ix += n; 938| | } 939| | if constexpr (not check_unquoted(Opts)) { 940| | std::memcpy(&b[ix], "\"", 1); 941| | ++ix; 942| | } 943| | } 944| 950| else { 945| 950| const sv str = [&]() -> const sv { 946| 950| if constexpr (array_char_t) { 947| 950| return sv{value.data(), value.size()}; 948| 950| } 949| 950| else if constexpr (u8str_t) { 950| 950| return sv{reinterpret_cast(value.data()), value.size()}; 951| 950| } 952| 950| else { 953| 950| return str_view(value); 954| 950| } 955| 950| }(); 956| 950| const auto n = str.size(); 957| | 958| | // In the case n == 0 we need two characters for quotes. 959| | // For each individual character we need room for two characters to handle escapes. 960| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 961| | if constexpr (check_escape_control_characters(Opts)) { 962| | if constexpr (has_bounded_capacity) { 963| | // 6 bytes per character is a ceiling only a string of nothing but control 964| | // characters reaches. A resizable buffer merely over-allocates against it, 965| | // but a fixed buffer has nowhere to grow, so the ceiling would reject output 966| | // that fits. Measuring the string answers exactly, at the cost of a pass over 967| | // it, so bracket the measurement between two O(1) bounds and only pay it when 968| | // the answer is still in doubt: the ceiling fitting means yes, and the floor 969| | // of one byte per character not fitting means no. 970| | const size_t capacity = buffer_traits>::capacity(b); 971| | size_t required = ix + 10 + 6 * n; 972| | if (required > capacity) [[unlikely]] { 973| | required = ix + 10 + n; 974| | if (required <= capacity) { 975| | required = ix + 10 + detail::escaped_string_size(str); 976| | } 977| | } 978| | if (!ensure_space(ctx, b, required)) [[unlikely]] { 979| | return; 980| | } 981| | } 982| | // We need 2 + 6 * n characters in the worst case (all control chars) 983| | else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 984| | return; 985| | } 986| | } 987| 950| else { 988| | // Using the original sizing 989| 950| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 950] ------------------ 990| 0| return; 991| 0| } 992| 950| } 993| | // now we don't have to check writing 994| | 995| | if constexpr (check_unquoted(Opts)) { 996| | if (n) { 997| | std::memcpy(&b[ix], str.data(), n); 998| | ix += n; 999| | } 1000| | } 1001| 950| else { 1002| 950| std::memcpy(&b[ix], "\"", 1); 1003| 950| ++ix; 1004| | 1005| 950| const auto* c = str.data(); 1006| 950| const auto* const e = c + n; 1007| 950| const auto start = &b[ix]; 1008| 950| auto data = start; 1009| | 1010| | // By default we don't escape control characters for performance. Invalid JSON characters 1011| | // result in null characters in the output, making the JSON invalid — these would then be 1012| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 1013| | // control characters (0x00–0x1F) as \uXXXX sequences. 1014| | 1015| | // Escape handler: writes the escaped form of *c into data, advances both pointers 1016| 950| auto write_escape = [&]() { 1017| 950| if constexpr (check_escape_control_characters(Opts)) { 1018| 950| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 950| std::memcpy(data, &escaped, 2); 1020| 950| data += 2; 1021| 950| } 1022| 950| else { 1023| 950| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 950| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 950| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 950| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 950| std::memcpy(data, unicode_escape, 6); 1028| 950| data += 6; 1029| 950| } 1030| 950| } 1031| 950| else { 1032| 950| if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| 950| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 950| ctx.error = error_code::invalid_control_character; 1040| 950| } 1041| 950| } 1042| 950| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 950| data += 2; 1044| 950| } 1045| 950| ++c; 1046| 950| }; 1047| | 1048| | // Adding a helper here means adding a branch to string_escape_simd() in 1049| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 1050| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 1051| |#if defined(GLZ_USE_AVX2) 1052| | detail::avx2_string_escape(c, e, data, n, write_escape); 1053| |#endif 1054| 950|#if defined(GLZ_USE_SSE2) 1055| 950| detail::sse2_string_escape(c, e, data, n, write_escape); 1056| |#elif defined(GLZ_USE_NEON) 1057| | detail::neon_string_escape(c, e, data, n, write_escape); 1058| |#endif 1059| | 1060| | // SWAR: 8 bytes at a time 1061| 950| if (n > 7) { ------------------ | Branch (1061:23): [True: 350, False: 600] ------------------ 1062| 728| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 378, False: 350] ------------------ 1063| 378| std::memcpy(data, c, 8); 1064| 378| uint64_t swar; 1065| 378| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 378| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 378| const uint64_t lo7 = swar & lo7_mask; 1072| 378| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 378| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 378| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 378| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 378| next &= repeat_byte8(0b10000000); 1078| 378| if (next == 0) { ------------------ | Branch (1078:29): [True: 191, False: 187] ------------------ 1079| 191| data += 8; 1080| 191| c += 8; 1081| 191| continue; 1082| 191| } 1083| | 1084| 187| const auto length = (countr_zero(next) >> 3); 1085| 187| c += length; 1086| 187| data += length; 1087| 187| write_escape(); 1088| 187| } 1089| 350| } 1090| | 1091| | // Scalar tail 1092| 3.34k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 2.39k, False: 950] ------------------ 1093| 2.39k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 238, False: 2.15k] ------------------ 1094| 238| std::memcpy(data, &escaped, 2); 1095| 238| data += 2; 1096| 238| } 1097| | else if constexpr (check_escape_control_characters(Opts)) { 1098| | if (uint8_t(*c) < 0x20) { 1099| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1100| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1101| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1102| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1103| | std::memcpy(data, unicode_escape, 6); 1104| | data += 6; 1105| | } 1106| | else { 1107| | std::memcpy(data, c, 1); 1108| | ++data; 1109| | } 1110| | } 1111| 2.15k| else { 1112| | if constexpr (check_reject_control_characters(Opts)) { 1113| | if (uint8_t(*c) < 0x20) [[unlikely]] { 1114| | ctx.error = error_code::invalid_control_character; 1115| | } 1116| | } 1117| 2.15k| std::memcpy(data, c, 1); 1118| 2.15k| ++data; 1119| 2.15k| } 1120| 2.39k| } 1121| | 1122| 950| ix += size_t(data - start); 1123| | 1124| 950| std::memcpy(&b[ix], "\"", 1); 1125| 950| ++ix; 1126| 950| } 1127| 950| } 1128| 950| } 1129| 950| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 950| const sv str = [&]() -> const sv { 946| | if constexpr (array_char_t) { 947| | return sv{value.data(), value.size()}; 948| | } 949| | else if constexpr (u8str_t) { 950| | return sv{reinterpret_cast(value.data()), value.size()}; 951| | } 952| 950| else { 953| 950| return str_view(value); 954| 950| } 955| 950| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 6.09k| auto write_escape = [&]() { 1017| | if constexpr (check_escape_control_characters(Opts)) { 1018| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| | std::memcpy(data, &escaped, 2); 1020| | data += 2; 1021| | } 1022| | else { 1023| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| | std::memcpy(data, unicode_escape, 6); 1028| | data += 6; 1029| | } 1030| | } 1031| 6.09k| else { 1032| | if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| | if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| | ctx.error = error_code::invalid_control_character; 1040| | } 1041| | } 1042| 6.09k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 6.09k| data += 2; 1044| 6.09k| } 1045| 6.09k| ++c; 1046| 6.09k| }; _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm2EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2465| 297| { 2466| 297| using ValueType = std::decay_t; 2467| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2468| | constexpr auto& writer = meta_unknown_write_v; 2469| | 2470| | using WriterType = meta_unknown_write_t; 2471| | if constexpr (std::is_member_object_pointer_v) { 2472| | decltype(auto) unknown_writer = value.*writer; 2473| | if (unknown_writer.size() > 0) { 2474| | // TODO: This intermediate is added to get GCC 14 to build 2475| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2476| | serialize::op()>(std::move(merged), ctx, b, ix); 2477| | } 2478| | else { 2479| | serialize::op()>(value, ctx, b, ix); 2480| | } 2481| | } 2482| | else if constexpr (std::is_member_function_pointer_v) { 2483| | decltype(auto) unknown_writer = (value.*writer)(); 2484| | if (unknown_writer.size() > 0) { 2485| | // TODO: This intermediate is added to get GCC 14 to build 2486| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2487| | serialize::op()>(std::move(merged), ctx, b, ix); 2488| | } 2489| | else { 2490| | serialize::op()>(value, ctx, b, ix); 2491| | } 2492| | } 2493| | else { 2494| | static_assert(false_v, "unknown_write type not handled"); 2495| | } 2496| | } 2497| 297| else { 2498| | // handles glaze_object_t without extra unknown fields 2499| 297| static constexpr auto Opts = 2500| 297| disable_write_unknown_off()>()>(); 2501| | 2502| 297| if constexpr (not check_opening_handled(Options)) { 2503| | if constexpr (Options.prettify) { 2504| | ctx.depth += check_indentation_width(Options); 2505| | if constexpr (not check_write_unchecked(Options)) { 2506| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2507| | return; 2508| | } 2509| | } 2510| | std::memcpy(&b[ix], "{\n", 2); 2511| | ix += 2; 2512| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2513| | ix += ctx.depth; 2514| | } 2515| 297| else { 2516| 297| if constexpr (not check_write_unchecked(Options)) { 2517| 297| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2517:26): [True: 0, False: 297] ------------------ 2518| 0| return; 2519| 0| } 2520| 297| } 2521| 297| dump('{', b, ix); 2522| 297| } 2523| 297| } 2524| | 2525| 0| static constexpr auto N = reflect::size; 2526| | 2527| 297| decltype(auto) t = [&]() -> decltype(auto) { 2528| 297| if constexpr (reflectable) { 2529| 297| return to_tie(value); 2530| 297| } 2531| 297| else { 2532| 297| return nullptr; 2533| 297| } 2534| 297| }(); 2535| | 2536| 297| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2537| | if constexpr (maybe_skipped) { 2538| | bool first = true; 2539| | for_each([&]() { 2540| | using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| | else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| | if (is_glaze_value_field_null(value, t)) return; 2598| | } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| | else { 2618| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2619| | return; 2620| | } 2621| | } 2622| | 2623| | if (first) { 2624| | first = false; 2625| | } 2626| | else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| | else { 2635| | std::memcpy(&b[ix], ",", 1); 2636| | ++ix; 2637| | } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| | } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| | static constexpr auto quoted_key = quoted_key_v; 2646| | static constexpr auto n = quoted_key.size(); 2647| | std::memcpy(&b[ix], quoted_key.data(), n); 2648| | ix += n; 2649| | 2650| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2651| | if constexpr (reflectable) { 2652| | to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| | } 2659| | }); 2660| | } 2661| 297| else { 2662| 297| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2662:57): [Folded, False: 297] ------------------ 2663| 297| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2664| 297| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2664:23): [True: 0, False: 297] ------------------ 2665| 0| return; 2666| 0| } 2667| 297| } 2668| | 2669| 297| for_each([&]() { 2670| 297| if constexpr (write_can_error()) { 2671| 297| if (bool(ctx.error)) [[unlikely]] { 2672| 297| return; 2673| 297| } 2674| 297| } 2675| 297| if constexpr (not fixed_max_size) { 2676| 297| if constexpr (Opts.prettify) { 2677| 297| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| 297| return; 2679| 297| } 2680| 297| } 2681| 297| else { 2682| 297| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| 297| return; 2684| 297| } 2685| 297| } 2686| 297| } 2687| | 2688| 297| if constexpr (I != 0 && Opts.prettify) { 2689| 297| std::memcpy(&b[ix], ",\n", 2); 2690| 297| ix += 2; 2691| 297| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| 297| ix += ctx.depth; 2693| 297| } 2694| | 2695| 297| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 297| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| 297| if constexpr (always_null_t) { 2700| 297| if constexpr (I == 0 || Opts.prettify) { 2701| 297| static constexpr auto quoted_key = join_v, chars<"null">>; 2702| 297| static constexpr auto n = quoted_key.size(); 2703| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2704| 297| ix += n; 2705| 297| } 2706| 297| else { 2707| 297| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| 297| static constexpr auto n = quoted_key.size(); 2709| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2710| 297| ix += n; 2711| 297| } 2712| 297| } 2713| 297| else { 2714| 297| if constexpr (I == 0 || Opts.prettify) { 2715| 297| static constexpr auto quoted_key = quoted_key_v; 2716| 297| static constexpr auto n = quoted_key.size(); 2717| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 297| ix += n; 2719| 297| } 2720| 297| else { 2721| 297| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 297| static constexpr auto n = quoted_key.size(); 2723| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 297| ix += n; 2725| 297| } 2726| | 2727| 297| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2728| 297| if constexpr (reflectable) { 2729| 297| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| 297| } 2731| 297| else { 2732| 297| to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| 297| ix); 2734| 297| } 2735| 297| } 2736| 297| }); 2737| 297| } 2738| | 2739| | // Options is required here, because it must be the top level 2740| 297| if constexpr (not check_closing_handled(Options)) { 2741| | if constexpr (Options.prettify) { 2742| | ctx.depth -= check_indentation_width(Options); 2743| | if constexpr (not check_write_unchecked(Options)) { 2744| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2745| | return; 2746| | } 2747| | } 2748| | std::memcpy(&b[ix], "\n", 1); 2749| | ++ix; 2750| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2751| | ix += ctx.depth; 2752| | std::memcpy(&b[ix], "}", 1); 2753| | ++ix; 2754| | } 2755| 297| else { 2756| 297| dump || check_write_unchecked(Options))>('}', b, ix); 2757| 297| } 2758| 297| } 2759| 297| } 2760| 297| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2527| 297| decltype(auto) t = [&]() -> decltype(auto) { 2528| 297| if constexpr (reflectable) { 2529| 297| return to_tie(value); 2530| | } 2531| | else { 2532| | return nullptr; 2533| | } 2534| 297| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2669| 297| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| | if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| | else { 2682| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| | return; 2684| | } 2685| | } 2686| | } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 297| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 297| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 297| else { 2714| 297| if constexpr (I == 0 || Opts.prettify) { 2715| 297| static constexpr auto quoted_key = quoted_key_v; 2716| 297| static constexpr auto n = quoted_key.size(); 2717| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 297| ix += n; 2719| | } 2720| | else { 2721| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| | static constexpr auto n = quoted_key.size(); 2723| | std::memcpy(&b[ix], quoted_key.data(), n); 2724| | ix += n; 2725| | } 2726| | 2727| 297| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [True: 0, Folded] ------------------ 2728| 297| if constexpr (reflectable) { 2729| 297| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 297| } 2736| 297| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2669| 297| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| | if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| | else { 2682| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| | return; 2684| | } 2685| | } 2686| | } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 297| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 297| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 297| else { 2714| | if constexpr (I == 0 || Opts.prettify) { 2715| | static constexpr auto quoted_key = quoted_key_v; 2716| | static constexpr auto n = quoted_key.size(); 2717| | std::memcpy(&b[ix], quoted_key.data(), n); 2718| | ix += n; 2719| | } 2720| 297| else { 2721| 297| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 297| static constexpr auto n = quoted_key.size(); 2723| 297| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 297| ix += n; 2725| 297| } 2726| | 2727| 297| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [True: 0, Folded] ------------------ 2728| 297| if constexpr (reflectable) { 2729| 297| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 297| } 2736| 297| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm3EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2465| 123| { 2466| 123| using ValueType = std::decay_t; 2467| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2468| | constexpr auto& writer = meta_unknown_write_v; 2469| | 2470| | using WriterType = meta_unknown_write_t; 2471| | if constexpr (std::is_member_object_pointer_v) { 2472| | decltype(auto) unknown_writer = value.*writer; 2473| | if (unknown_writer.size() > 0) { 2474| | // TODO: This intermediate is added to get GCC 14 to build 2475| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2476| | serialize::op()>(std::move(merged), ctx, b, ix); 2477| | } 2478| | else { 2479| | serialize::op()>(value, ctx, b, ix); 2480| | } 2481| | } 2482| | else if constexpr (std::is_member_function_pointer_v) { 2483| | decltype(auto) unknown_writer = (value.*writer)(); 2484| | if (unknown_writer.size() > 0) { 2485| | // TODO: This intermediate is added to get GCC 14 to build 2486| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2487| | serialize::op()>(std::move(merged), ctx, b, ix); 2488| | } 2489| | else { 2490| | serialize::op()>(value, ctx, b, ix); 2491| | } 2492| | } 2493| | else { 2494| | static_assert(false_v, "unknown_write type not handled"); 2495| | } 2496| | } 2497| 123| else { 2498| | // handles glaze_object_t without extra unknown fields 2499| 123| static constexpr auto Opts = 2500| 123| disable_write_unknown_off()>()>(); 2501| | 2502| 123| if constexpr (not check_opening_handled(Options)) { 2503| | if constexpr (Options.prettify) { 2504| | ctx.depth += check_indentation_width(Options); 2505| | if constexpr (not check_write_unchecked(Options)) { 2506| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2507| | return; 2508| | } 2509| | } 2510| | std::memcpy(&b[ix], "{\n", 2); 2511| | ix += 2; 2512| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2513| | ix += ctx.depth; 2514| | } 2515| 123| else { 2516| 123| if constexpr (not check_write_unchecked(Options)) { 2517| 123| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2517:26): [True: 0, False: 123] ------------------ 2518| 0| return; 2519| 0| } 2520| 123| } 2521| 123| dump('{', b, ix); 2522| 123| } 2523| 123| } 2524| | 2525| 0| static constexpr auto N = reflect::size; 2526| | 2527| 123| decltype(auto) t = [&]() -> decltype(auto) { 2528| 123| if constexpr (reflectable) { 2529| 123| return to_tie(value); 2530| 123| } 2531| 123| else { 2532| 123| return nullptr; 2533| 123| } 2534| 123| }(); 2535| | 2536| 123| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2537| | if constexpr (maybe_skipped) { 2538| | bool first = true; 2539| | for_each([&]() { 2540| | using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| | else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| | if (is_glaze_value_field_null(value, t)) return; 2598| | } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| | else { 2618| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2619| | return; 2620| | } 2621| | } 2622| | 2623| | if (first) { 2624| | first = false; 2625| | } 2626| | else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| | else { 2635| | std::memcpy(&b[ix], ",", 1); 2636| | ++ix; 2637| | } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| | } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| | static constexpr auto quoted_key = quoted_key_v; 2646| | static constexpr auto n = quoted_key.size(); 2647| | std::memcpy(&b[ix], quoted_key.data(), n); 2648| | ix += n; 2649| | 2650| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2651| | if constexpr (reflectable) { 2652| | to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| | } 2659| | }); 2660| | } 2661| 123| else { 2662| 123| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2662:57): [Folded, False: 123] ------------------ 2663| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2664| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2665| | return; 2666| | } 2667| | } 2668| | 2669| 123| for_each([&]() { 2670| 123| if constexpr (write_can_error()) { 2671| 123| if (bool(ctx.error)) [[unlikely]] { 2672| 123| return; 2673| 123| } 2674| 123| } 2675| 123| if constexpr (not fixed_max_size) { 2676| 123| if constexpr (Opts.prettify) { 2677| 123| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| 123| return; 2679| 123| } 2680| 123| } 2681| 123| else { 2682| 123| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2683| 123| return; 2684| 123| } 2685| 123| } 2686| 123| } 2687| | 2688| 123| if constexpr (I != 0 && Opts.prettify) { 2689| 123| std::memcpy(&b[ix], ",\n", 2); 2690| 123| ix += 2; 2691| 123| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| 123| ix += ctx.depth; 2693| 123| } 2694| | 2695| 123| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 123| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| 123| if constexpr (always_null_t) { 2700| 123| if constexpr (I == 0 || Opts.prettify) { 2701| 123| static constexpr auto quoted_key = join_v, chars<"null">>; 2702| 123| static constexpr auto n = quoted_key.size(); 2703| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2704| 123| ix += n; 2705| 123| } 2706| 123| else { 2707| 123| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| 123| static constexpr auto n = quoted_key.size(); 2709| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2710| 123| ix += n; 2711| 123| } 2712| 123| } 2713| 123| else { 2714| 123| if constexpr (I == 0 || Opts.prettify) { 2715| 123| static constexpr auto quoted_key = quoted_key_v; 2716| 123| static constexpr auto n = quoted_key.size(); 2717| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 123| ix += n; 2719| 123| } 2720| 123| else { 2721| 123| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 123| static constexpr auto n = quoted_key.size(); 2723| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 123| ix += n; 2725| 123| } 2726| | 2727| 123| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2728| 123| if constexpr (reflectable) { 2729| 123| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| 123| } 2731| 123| else { 2732| 123| to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| 123| ix); 2734| 123| } 2735| 123| } 2736| 123| }); 2737| 123| } 2738| | 2739| | // Options is required here, because it must be the top level 2740| 123| if constexpr (not check_closing_handled(Options)) { 2741| | if constexpr (Options.prettify) { 2742| | ctx.depth -= check_indentation_width(Options); 2743| | if constexpr (not check_write_unchecked(Options)) { 2744| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2745| | return; 2746| | } 2747| | } 2748| | std::memcpy(&b[ix], "\n", 1); 2749| | ++ix; 2750| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2751| | ix += ctx.depth; 2752| | std::memcpy(&b[ix], "}", 1); 2753| | ++ix; 2754| | } 2755| 123| else { 2756| 123| dump || check_write_unchecked(Options))>('}', b, ix); 2757| 123| } 2758| 123| } 2759| 123| } 2760| 123| } _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2527| 123| decltype(auto) t = [&]() -> decltype(auto) { 2528| 123| if constexpr (reflectable) { 2529| 123| return to_tie(value); 2530| | } 2531| | else { 2532| | return nullptr; 2533| | } 2534| 123| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2669| 123| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| 123| if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| 123| else { 2682| 123| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2682:29): [True: 0, False: 123] ------------------ 2683| 0| return; 2684| 0| } 2685| 123| } 2686| 123| } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 123| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 123| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 123| else { 2714| 123| if constexpr (I == 0 || Opts.prettify) { 2715| 123| static constexpr auto quoted_key = quoted_key_v; 2716| 123| static constexpr auto n = quoted_key.size(); 2717| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2718| 123| ix += n; 2719| | } 2720| | else { 2721| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| | static constexpr auto n = quoted_key.size(); 2723| | std::memcpy(&b[ix], quoted_key.data(), n); 2724| | ix += n; 2725| | } 2726| | 2727| 123| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [True: 0, Folded] ------------------ 2728| 123| if constexpr (reflectable) { 2729| 123| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 123| } 2736| 123| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2669| 123| for_each([&]() { 2670| | if constexpr (write_can_error()) { 2671| | if (bool(ctx.error)) [[unlikely]] { 2672| | return; 2673| | } 2674| | } 2675| 123| if constexpr (not fixed_max_size) { 2676| | if constexpr (Opts.prettify) { 2677| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2678| | return; 2679| | } 2680| | } 2681| 123| else { 2682| 123| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2682:29): [True: 0, False: 123] ------------------ 2683| 0| return; 2684| 0| } 2685| 123| } 2686| 123| } 2687| | 2688| | if constexpr (I != 0 && Opts.prettify) { 2689| | std::memcpy(&b[ix], ",\n", 2); 2690| | ix += 2; 2691| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2692| | ix += ctx.depth; 2693| | } 2694| | 2695| 123| using val_t = field_t; 2696| | 2697| | // MSVC requires get rather than keys[I] 2698| 123| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2699| | if constexpr (always_null_t) { 2700| | if constexpr (I == 0 || Opts.prettify) { 2701| | static constexpr auto quoted_key = join_v, chars<"null">>; 2702| | static constexpr auto n = quoted_key.size(); 2703| | std::memcpy(&b[ix], quoted_key.data(), n); 2704| | ix += n; 2705| | } 2706| | else { 2707| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2708| | static constexpr auto n = quoted_key.size(); 2709| | std::memcpy(&b[ix], quoted_key.data(), n); 2710| | ix += n; 2711| | } 2712| | } 2713| 123| else { 2714| | if constexpr (I == 0 || Opts.prettify) { 2715| | static constexpr auto quoted_key = quoted_key_v; 2716| | static constexpr auto n = quoted_key.size(); 2717| | std::memcpy(&b[ix], quoted_key.data(), n); 2718| | ix += n; 2719| | } 2720| 123| else { 2721| 123| static constexpr auto quoted_key = join_v, quoted_key_v>; 2722| 123| static constexpr auto n = quoted_key.size(); 2723| 123| std::memcpy(&b[ix], quoted_key.data(), n); 2724| 123| ix += n; 2725| 123| } 2726| | 2727| 123| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2727:57): [Folded, False: 123] ------------------ 2728| 123| if constexpr (reflectable) { 2729| 123| to::template op(get_member(value, get(t)), ctx, b, ix); 2730| | } 2731| | else { 2732| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2733| | ix); 2734| | } 2735| 123| } 2736| 123| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm4EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS3_IcEEEERS5_TkNS_10is_contextERNS_7contextEmQaa16writable_array_tIT_EquL_ZNS0_ILj10ESI_E14map_like_arrayEEeqcl17check_concatenateTL0__ELb0ELb1EEEvOT1_OT2_OT0_RT3_: 1426| 175| { 1427| 175| if (empty_range(value)) { ------------------ | Branch (1427:14): [True: 175, False: 0] ------------------ 1428| 175| dump("[]", b, ix); 1429| 175| } 1430| 0| else { 1431| | // For bounded buffers, skip pre-allocation path since value_padding is for SIMD, not actual size 1432| 0| if constexpr (has_size && array_padding_known && !has_bounded_capacity) { 1433| 0| const auto n = value.size(); 1434| | 1435| 0| static constexpr auto value_padding = []() -> size_t { 1436| 0| if constexpr (required_padding() > 0) 1437| 0| return required_padding(); 1438| 0| else 1439| 0| return fixed_padding; 1440| 0| }(); 1441| | 1442| | if constexpr (Opts.prettify) { 1443| | if constexpr (check_new_lines_in_arrays(Opts)) { 1444| | ctx.depth += check_indentation_width(Opts); 1445| | } 1446| | 1447| | // add space for '\n' and ',' characters for each element, hence `+ 2` 1448| | // use n + 1 because we put the end array character after the last element with whitespace 1449| | if (!ensure_space(ctx, b, ix + (n + 1) * (value_padding + ctx.depth + 2) + write_padding_bytes)) 1450| | [[unlikely]] { 1451| | return; 1452| | } 1453| | 1454| | if constexpr (check_new_lines_in_arrays(Opts)) { 1455| | std::memcpy(&b[ix], "[\n", 2); 1456| | ix += 2; 1457| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1458| | ix += ctx.depth; 1459| | } 1460| | else { 1461| | std::memcpy(&b[ix], "[", 1); 1462| | ++ix; 1463| | } 1464| | } 1465| 0| else { 1466| 0| static constexpr auto comma_padding = 1; 1467| 0| if (!ensure_space(ctx, b, ix + n * (value_padding + comma_padding) + write_padding_bytes)) ------------------ | Branch (1467:23): [True: 0, False: 0] ------------------ 1468| 0| [[unlikely]] { 1469| 0| return; 1470| 0| } 1471| 0| std::memcpy(&b[ix], "[", 1); 1472| 0| ++ix; 1473| 0| } 1474| | 1475| 0| auto it = std::begin(value); 1476| 0| using val_t = std::remove_cvref_t; 1477| 0| to::template op()>(*it, ctx, b, ix); 1478| | 1479| 0| ++it; 1480| 0| for (const auto fin = std::end(value); it != fin; ++it) { ------------------ | Branch (1480:55): [True: 0, False: 0] ------------------ 1481| | if constexpr (Opts.prettify) { 1482| | if constexpr (check_new_lines_in_arrays(Opts)) { 1483| | std::memcpy(&b[ix], ",\n", 2); 1484| | ix += 2; 1485| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1486| | ix += ctx.depth; 1487| | } 1488| | else { 1489| | std::memcpy(&b[ix], ", ", 2); 1490| | ix += 2; 1491| | } 1492| | } 1493| 0| else { 1494| 0| std::memcpy(&b[ix], ",", 1); 1495| 0| ++ix; 1496| 0| } 1497| | if constexpr (is_output_streaming) { 1498| | flush_buffer(b, ix); 1499| | } 1500| | 1501| 0| to::template op()>(*it, ctx, b, ix); 1502| 0| } 1503| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1504| | ctx.depth -= check_indentation_width(Opts); 1505| | std::memcpy(&b[ix], "\n", 1); 1506| | ++ix; 1507| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1508| | ix += ctx.depth; 1509| | } 1510| | 1511| 0| std::memcpy(&b[ix], "]", 1); 1512| 0| ++ix; 1513| | } 1514| | else { 1515| | // we either can't get the size (std::forward_list) or we cannot compute the allocation size 1516| | 1517| | if constexpr (Opts.prettify) { 1518| | if constexpr (check_new_lines_in_arrays(Opts)) { 1519| | ctx.depth += check_indentation_width(Opts); 1520| | } 1521| | 1522| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1523| | return; 1524| | } 1525| | 1526| | if constexpr (check_new_lines_in_arrays(Opts)) { 1527| | std::memcpy(&b[ix], "[\n", 2); 1528| | ix += 2; 1529| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1530| | ix += ctx.depth; 1531| | } 1532| | else { 1533| | std::memcpy(&b[ix], "[", 1); 1534| | ++ix; 1535| | } 1536| | } 1537| | else { 1538| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1539| | return; 1540| | } 1541| | std::memcpy(&b[ix], "[", 1); 1542| | ++ix; 1543| | } 1544| | 1545| | auto it = std::begin(value); 1546| | using val_t = std::remove_cvref_t; 1547| | if constexpr (required_padding()) { 1548| | to::template op()>(*it, ctx, b, ix); 1549| | } 1550| | else { 1551| | to::template op(*it, ctx, b, ix); 1552| | if (bool(ctx.error)) [[unlikely]] { 1553| | return; 1554| | } 1555| | } 1556| | 1557| | ++it; 1558| | for (const auto fin = std::end(value); it != fin; ++it) { 1559| | if constexpr (required_padding()) { 1560| | if constexpr (Opts.prettify) { 1561| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1562| | return; 1563| | } 1564| | } 1565| | else { 1566| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1567| | return; 1568| | } 1569| | } 1570| | 1571| | if constexpr (Opts.prettify) { 1572| | if constexpr (check_new_lines_in_arrays(Opts)) { 1573| | std::memcpy(&b[ix], ",\n", 2); 1574| | ix += 2; 1575| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1576| | ix += ctx.depth; 1577| | } 1578| | else { 1579| | std::memcpy(&b[ix], ", ", 2); 1580| | ix += 2; 1581| | } 1582| | } 1583| | else { 1584| | std::memcpy(&b[ix], ",", 1); 1585| | ++ix; 1586| | } 1587| | if constexpr (is_output_streaming) { 1588| | flush_buffer(b, ix); 1589| | } 1590| | 1591| | to::template op()>(*it, ctx, b, ix); 1592| | } 1593| | else { 1594| | write_array_entry_separator(ctx, b, ix); 1595| | to::template op(*it, ctx, b, ix); 1596| | if (bool(ctx.error)) [[unlikely]] { 1597| | return; 1598| | } 1599| | } 1600| | } 1601| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1602| | ctx.depth -= check_indentation_width(Opts); 1603| | dump_newline_indent(check_indentation_char(Opts), ctx.depth, b, ix); 1604| | } 1605| | 1606| | dump(']', b, ix); 1607| | } 1608| 0| } 1609| 175| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm5EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSF_TkNS_10is_contextERNS_7contextEmQoo14writable_map_tIT_EaaL_ZNS0_ILj10ESN_E14map_like_arrayEEeqcl17check_concatenateTL0__ELb1EEEvOT1_OT2_OT0_RT3_: 1614| 103| { 1615| 103| if constexpr (not check_opening_handled(Opts)) { 1616| 103| dump('{', b, ix); 1617| 103| } 1618| | 1619| 103| if (!empty_range(value)) { ------------------ | Branch (1619:14): [True: 0, False: 103] ------------------ 1620| 0| if constexpr (!check_opening_handled(Opts)) { 1621| | if constexpr (Opts.prettify) { 1622| | ctx.depth += check_indentation_width(Opts); 1623| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1624| | return; 1625| | } 1626| | std::memcpy(&b[ix], "\n", 1); 1627| | ++ix; 1628| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1629| | ix += ctx.depth; 1630| | } 1631| 0| } 1632| | 1633| 0| using val_t = detail::iterator_second_type; // the type of value in each [key, value] pair 1634| 0| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 1635| 0| if constexpr (!always_skipped && (write_function_pointers || !is_any_function_ptr)) { 1636| | if constexpr (null_t && Opts.skip_null_members) { 1637| | auto write_first_entry = [&](auto&& it) { 1638| | auto&& [key, entry_val] = *it; 1639| | if (skip_member(entry_val)) { 1640| | return true; 1641| | } 1642| | write_pair_content(key, entry_val, ctx, b, ix); 1643| | return bool(ctx.error); 1644| | }; 1645| | 1646| | auto it = std::begin(value); 1647| | bool first = write_first_entry(it); 1648| | if (bool(ctx.error)) [[unlikely]] { 1649| | return; 1650| | } 1651| | ++it; 1652| | for (const auto end = std::end(value); it != end; ++it) { 1653| | auto&& [key, entry_val] = *it; 1654| | if (skip_member(entry_val)) { 1655| | continue; 1656| | } 1657| | 1658| | // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be 1659| | // conditional for every entry. 1660| | // Alternatively, write separator after each entry except last but then branch is permanent 1661| | if (not first) { 1662| | write_object_entry_separator(ctx, b, ix); 1663| | } 1664| | 1665| | write_pair_content(key, entry_val, ctx, b, ix); 1666| | if (bool(ctx.error)) [[unlikely]] { 1667| | return; 1668| | } 1669| | 1670| | first = false; 1671| | } 1672| | } 1673| 0| else { 1674| 0| auto write_first_entry = [&](auto&& it) { 1675| 0| auto&& [key, entry_val] = *it; 1676| 0| write_pair_content(key, entry_val, ctx, b, ix); 1677| 0| }; 1678| | 1679| 0| auto it = std::begin(value); 1680| 0| write_first_entry(it); 1681| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1681:23): [True: 0, False: 0] ------------------ 1682| 0| return; 1683| 0| } 1684| 0| ++it; 1685| 0| for (const auto end = std::end(value); it != end; ++it) { ------------------ | Branch (1685:58): [True: 0, False: 0] ------------------ 1686| 0| auto&& [key, entry_val] = *it; 1687| 0| write_object_entry_separator(ctx, b, ix); 1688| 0| write_pair_content(key, entry_val, ctx, b, ix); 1689| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1689:26): [True: 0, False: 0] ------------------ 1690| 0| return; 1691| 0| } 1692| 0| } 1693| 0| } 1694| 0| } 1695| | 1696| 0| if constexpr (!check_closing_handled(Opts)) { 1697| | if constexpr (Opts.prettify) { 1698| | ctx.depth -= check_indentation_width(Opts); 1699| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1700| | return; 1701| | } 1702| | std::memcpy(&b[ix], "\n", 1); 1703| | ++ix; 1704| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1705| | ix += ctx.depth; 1706| | } 1707| 0| } 1708| 0| } 1709| | 1710| 103| if constexpr (!check_closing_handled(Opts)) { 1711| 103| dump('}', b, ix); 1712| 103| } 1713| 103| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| 50| if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| 50| else { 2569| 50| const auto is_null = [&]() { 2570| 50| decltype(auto) element = [&]() -> decltype(auto) { 2571| 50| if constexpr (reflectable) { 2572| 50| return get(t); 2573| 50| } 2574| 50| else { 2575| 50| return get(reflect::values); 2576| 50| } 2577| 50| }; 2578| | 2579| 50| if constexpr (nullable_wrapper) { 2580| 50| return !bool(element()(value).val); 2581| 50| } 2582| 50| else if constexpr (nullable_value_t) { 2583| 50| return !get_member(value, element()).has_value(); 2584| 50| } 2585| 50| else { 2586| 50| return !bool(get_member(value, element())); 2587| 50| } 2588| 50| }(); 2589| 50| if (is_null) return; ------------------ | Branch (2589:32): [True: 50, False: 0] ------------------ 2590| 50| } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| | if (is_glaze_value_field_null(value, t)) return; 2598| | } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [True: 0, Folded] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDavENKUlvE_clEv: 2569| 50| const auto is_null = [&]() { 2570| 50| decltype(auto) element = [&]() -> decltype(auto) { 2571| 50| if constexpr (reflectable) { 2572| 50| return get(t); 2573| 50| } 2574| 50| else { 2575| 50| return get(reflect::values); 2576| 50| } 2577| 50| }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| 50| else if constexpr (nullable_value_t) { 2583| 50| return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| 50| }(); _ZZZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDavENKUlvE_clEvENKUlvE_clEv: 2570| 50| decltype(auto) element = [&]() -> decltype(auto) { 2571| 50| if constexpr (reflectable) { 2572| 50| return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| 50| }; _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm7EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1947| 123| { 1948| | // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are 1949| | // written side by side whatever the alternative is. The visit below still instantiates in 1950| | // that mode (`if constexpr` does not discard the statements after it), but both of its 1951| | // tagged branches are compile-time dead there and the runtime `return` keeps it unreached. 1952| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) { 1953| | write_adjacent(value, ctx, b, ix); 1954| | return; 1955| | } 1956| 123| std::visit( 1957| 123| [&](auto&& val) { 1958| 123| using V = std::decay_t; 1959| | 1960| 123| if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| 123| custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| 123| if (missing_id(value, ctx)) { 1972| 123| return; 1973| 123| } 1974| 123| using id_type = std::decay_t[value.index()])>; 1975| 123| if constexpr (Opts.prettify) { 1976| 123| dump("{\n", b, ix); 1977| 123| ctx.depth += check_indentation_width(Opts); 1978| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| 123| dump('"', b, ix); 1980| 123| dump_maybe_empty(tag_v, b, ix); 1981| 123| if constexpr (std::integral) { 1982| 123| dump("\": ", b, ix); 1983| 123| serialize::op(ids_v[value.index()], ctx, b, ix); 1984| 123| } 1985| 123| else { 1986| 123| dump("\": \"", b, ix); 1987| 123| dump_maybe_empty(ids_v[value.index()], b, ix); 1988| 123| dump('"', b, ix); 1989| 123| } 1990| 123| const auto pos_after_tag = ix; 1991| 123| dump(",\n", b, ix); 1992| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| 123| const auto pos_body_start = ix; 1994| 123| to::template op()>(val, ctx, b, ix); 1995| 123| if (ix == pos_body_start) { 1996| 123| ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| 123| } 1998| 123| ctx.depth -= check_indentation_width(Opts); 1999| 123| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| 123| return; 2001| 123| } 2002| 123| std::memcpy(&b[ix], "\n", 1); 2003| 123| ++ix; 2004| 123| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| 123| ix += ctx.depth; 2006| 123| std::memcpy(&b[ix], "}", 1); 2007| 123| ++ix; 2008| 123| } 2009| 123| else { 2010| 123| dump("{\"", b, ix); 2011| 123| dump_maybe_empty(tag_v, b, ix); 2012| 123| if constexpr (std::integral) { 2013| 123| dump("\":", b, ix); 2014| 123| serialize::op(ids_v[value.index()], ctx, b, ix); 2015| 123| } 2016| 123| else { 2017| 123| dump("\":\"", b, ix); 2018| 123| dump_maybe_empty(ids_v[value.index()], b, ix); 2019| 123| dump('"', b, ix); 2020| 123| } 2021| 123| const auto pos_after_tag = ix; 2022| 123| dump(',', b, ix); 2023| 123| const auto pos_body_start = ix; 2024| 123| to::template op()>(val, ctx, b, ix); 2025| 123| if (ix == pos_body_start) { 2026| 123| ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| 123| } 2028| 123| dump('}', b, ix); 2029| 123| } 2030| 123| } 2031| 123| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| 123| variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| 123| if (missing_id(value, ctx)) { 2036| 123| return; 2037| 123| } 2038| 123| if constexpr (Opts.prettify) { 2039| 123| dump("{\n", b, ix); 2040| 123| ctx.depth += check_indentation_width(Opts); 2041| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| 123| dump('"', b, ix); 2043| 123| dump_maybe_empty(tag_v, b, ix); 2044| 123| dump("\": ", b, ix); 2045| 123| write_id(value, ctx, b, ix); 2046| 123| ctx.depth -= check_indentation_width(Opts); 2047| 123| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| 123| return; 2049| 123| } 2050| 123| std::memcpy(&b[ix], "\n", 1); 2051| 123| ++ix; 2052| 123| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| 123| ix += ctx.depth; 2054| 123| std::memcpy(&b[ix], "}", 1); 2055| 123| ++ix; 2056| 123| } 2057| 123| else { 2058| 123| dump("{\"", b, ix); 2059| 123| dump_maybe_empty(tag_v, b, ix); 2060| 123| dump("\":", b, ix); 2061| 123| write_id(value, ctx, b, ix); 2062| 123| dump('}', b, ix); 2063| 123| } 2064| 123| } 2065| 123| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| 123| (glaze_object_t || reflectable || is_memory_object) && 2067| 123| (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| 123| if (missing_id(value, ctx)) { 2073| 123| return; 2074| 123| } 2075| 123| constexpr auto N = []() { 2076| 123| if constexpr (is_memory_object) { 2077| 123| return reflect>::size; 2078| 123| } 2079| 123| else { 2080| 123| return reflect::size; 2081| 123| } 2082| 123| }(); 2083| | 2084| | // must first write out type 2085| 123| if constexpr (Opts.prettify) { 2086| 123| dump("{\n", b, ix); 2087| 123| ctx.depth += check_indentation_width(Opts); 2088| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| 123| dump('"', b, ix); 2090| 123| dump_maybe_empty(tag_v, b, ix); 2091| | 2092| 123| using id_type = std::decay_t[value.index()])>; 2093| | 2094| 123| if constexpr (std::integral) { 2095| 123| dump("\": ", b, ix); 2096| 123| serialize::op(ids_v[value.index()], ctx, b, ix); 2097| 123| if constexpr (N > 0) { 2098| 123| dump(",\n", b, ix); 2099| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| 123| } 2101| 123| } 2102| 123| else { 2103| 123| dump("\": \"", b, ix); 2104| 123| dump_maybe_empty(ids_v[value.index()], b, ix); 2105| 123| if constexpr (N == 0) { 2106| 123| dump('"', b, ix); 2107| 123| } 2108| 123| else { 2109| 123| dump("\",\n", b, ix); 2110| 123| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| 123| } 2112| 123| } 2113| 123| } 2114| 123| else { 2115| 123| using id_type = std::decay_t[value.index()])>; 2116| | 2117| 123| dump("{\"", b, ix); 2118| 123| dump_maybe_empty(tag_v, b, ix); 2119| | 2120| 123| if constexpr (std::integral) { 2121| 123| dump("\":", b, ix); 2122| 123| serialize::op(ids_v[value.index()], ctx, b, ix); 2123| 123| if constexpr (N > 0) { 2124| 123| dump(',', b, ix); 2125| 123| } 2126| 123| } 2127| 123| else { 2128| 123| dump("\":\"", b, ix); 2129| 123| dump_maybe_empty(ids_v[value.index()], b, ix); 2130| 123| if constexpr (N == 0) { 2131| 123| dump('"', b, ix); 2132| 123| } 2133| 123| else { 2134| 123| dump("\",", b, ix); 2135| 123| } 2136| 123| } 2137| 123| } 2138| 123| if constexpr (is_memory_object) { 2139| 123| if (!val) [[unlikely]] { 2140| 123| ctx.error = error_code::invalid_variant_object; 2141| 123| return; 2142| 123| } 2143| 123| to>::template op()>(*val, ctx, b, ix); 2144| 123| } 2145| 123| else { 2146| 123| to::template op()>(val, ctx, b, ix); 2147| 123| } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| 123| if constexpr (Opts.skip_null_members) { 2150| 123| if (b[ix - 1] == ',') { 2151| 123| --ix; 2152| 123| } 2153| 123| } 2154| | 2155| 123| if constexpr (Opts.prettify) { 2156| 123| ctx.depth -= check_indentation_width(Opts); 2157| 123| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| 123| return; 2159| 123| } 2160| 123| std::memcpy(&b[ix], "\n", 1); 2161| 123| ++ix; 2162| 123| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| 123| ix += ctx.depth; 2164| 123| std::memcpy(&b[ix], "}", 1); 2165| 123| ++ix; 2166| 123| } 2167| 123| else { 2168| 123| dump('}', b, ix); 2169| 123| } 2170| 123| } 2171| 123| else { 2172| 123| to::template op(val, ctx, b, ix); 2173| 123| } 2174| 123| }, 2175| 123| value); 2176| 123| } _ZZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clISF_EEDaSS_: 1957| 123| [&](auto&& val) { 1958| 123| using V = std::decay_t; 1959| | 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1961| | custom_write) { 1962| | // Custom alternative: the user's serializer emits the object body, into which we 1963| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1964| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1965| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1966| | // scalar/array, or that ignores those flags, would yield malformed output. 1967| | // 1968| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1969| | // two in sync. The body size is not known at compile time, so we always write the 1970| | // tag separator and then drop it at runtime if the body turned out empty. 1971| | if (missing_id(value, ctx)) { 1972| | return; 1973| | } 1974| | using id_type = std::decay_t[value.index()])>; 1975| | if constexpr (Opts.prettify) { 1976| | dump("{\n", b, ix); 1977| | ctx.depth += check_indentation_width(Opts); 1978| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1979| | dump('"', b, ix); 1980| | dump_maybe_empty(tag_v, b, ix); 1981| | if constexpr (std::integral) { 1982| | dump("\": ", b, ix); 1983| | serialize::op(ids_v[value.index()], ctx, b, ix); 1984| | } 1985| | else { 1986| | dump("\": \"", b, ix); 1987| | dump_maybe_empty(ids_v[value.index()], b, ix); 1988| | dump('"', b, ix); 1989| | } 1990| | const auto pos_after_tag = ix; 1991| | dump(",\n", b, ix); 1992| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1993| | const auto pos_body_start = ix; 1994| | to::template op()>(val, ctx, b, ix); 1995| | if (ix == pos_body_start) { 1996| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1997| | } 1998| | ctx.depth -= check_indentation_width(Opts); 1999| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2000| | return; 2001| | } 2002| | std::memcpy(&b[ix], "\n", 1); 2003| | ++ix; 2004| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2005| | ix += ctx.depth; 2006| | std::memcpy(&b[ix], "}", 1); 2007| | ++ix; 2008| | } 2009| | else { 2010| | dump("{\"", b, ix); 2011| | dump_maybe_empty(tag_v, b, ix); 2012| | if constexpr (std::integral) { 2013| | dump("\":", b, ix); 2014| | serialize::op(ids_v[value.index()], ctx, b, ix); 2015| | } 2016| | else { 2017| | dump("\":\"", b, ix); 2018| | dump_maybe_empty(ids_v[value.index()], b, ix); 2019| | dump('"', b, ix); 2020| | } 2021| | const auto pos_after_tag = ix; 2022| | dump(',', b, ix); 2023| | const auto pos_body_start = ix; 2024| | to::template op()>(val, ctx, b, ix); 2025| | if (ix == pos_body_start) { 2026| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2027| | } 2028| | dump('}', b, ix); 2029| | } 2030| | } 2031| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2032| | variant_unit_alternative) { 2033| | // A unit alternative carries no data, so internal tagging renders it as the 2034| | // discriminator alone -- the same object an empty struct alternative produces. 2035| | if (missing_id(value, ctx)) { 2036| | return; 2037| | } 2038| | if constexpr (Opts.prettify) { 2039| | dump("{\n", b, ix); 2040| | ctx.depth += check_indentation_width(Opts); 2041| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2042| | dump('"', b, ix); 2043| | dump_maybe_empty(tag_v, b, ix); 2044| | dump("\": ", b, ix); 2045| | write_id(value, ctx, b, ix); 2046| | ctx.depth -= check_indentation_width(Opts); 2047| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2048| | return; 2049| | } 2050| | std::memcpy(&b[ix], "\n", 1); 2051| | ++ix; 2052| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2053| | ix += ctx.depth; 2054| | std::memcpy(&b[ix], "}", 1); 2055| | ++ix; 2056| | } 2057| | else { 2058| | dump("{\"", b, ix); 2059| | dump_maybe_empty(tag_v, b, ix); 2060| | dump("\":", b, ix); 2061| | write_id(value, ctx, b, ix); 2062| | dump('}', b, ix); 2063| | } 2064| | } 2065| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2066| | (glaze_object_t || reflectable || is_memory_object) && 2067| | (not alternative_declares_key(tag_v))) { 2068| | // An alternative that declares a member named like the discriminator carries the 2069| | // discriminator itself, so no tag is merged here and the bare-write branch below 2070| | // handles it. Previously only `reflectable` alternatives were excluded; a 2071| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2072| | if (missing_id(value, ctx)) { 2073| | return; 2074| | } 2075| | constexpr auto N = []() { 2076| | if constexpr (is_memory_object) { 2077| | return reflect>::size; 2078| | } 2079| | else { 2080| | return reflect::size; 2081| | } 2082| | }(); 2083| | 2084| | // must first write out type 2085| | if constexpr (Opts.prettify) { 2086| | dump("{\n", b, ix); 2087| | ctx.depth += check_indentation_width(Opts); 2088| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2089| | dump('"', b, ix); 2090| | dump_maybe_empty(tag_v, b, ix); 2091| | 2092| | using id_type = std::decay_t[value.index()])>; 2093| | 2094| | if constexpr (std::integral) { 2095| | dump("\": ", b, ix); 2096| | serialize::op(ids_v[value.index()], ctx, b, ix); 2097| | if constexpr (N > 0) { 2098| | dump(",\n", b, ix); 2099| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2100| | } 2101| | } 2102| | else { 2103| | dump("\": \"", b, ix); 2104| | dump_maybe_empty(ids_v[value.index()], b, ix); 2105| | if constexpr (N == 0) { 2106| | dump('"', b, ix); 2107| | } 2108| | else { 2109| | dump("\",\n", b, ix); 2110| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2111| | } 2112| | } 2113| | } 2114| | else { 2115| | using id_type = std::decay_t[value.index()])>; 2116| | 2117| | dump("{\"", b, ix); 2118| | dump_maybe_empty(tag_v, b, ix); 2119| | 2120| | if constexpr (std::integral) { 2121| | dump("\":", b, ix); 2122| | serialize::op(ids_v[value.index()], ctx, b, ix); 2123| | if constexpr (N > 0) { 2124| | dump(',', b, ix); 2125| | } 2126| | } 2127| | else { 2128| | dump("\":\"", b, ix); 2129| | dump_maybe_empty(ids_v[value.index()], b, ix); 2130| | if constexpr (N == 0) { 2131| | dump('"', b, ix); 2132| | } 2133| | else { 2134| | dump("\",", b, ix); 2135| | } 2136| | } 2137| | } 2138| | if constexpr (is_memory_object) { 2139| | if (!val) [[unlikely]] { 2140| | ctx.error = error_code::invalid_variant_object; 2141| | return; 2142| | } 2143| | to>::template op()>(*val, ctx, b, ix); 2144| | } 2145| | else { 2146| | to::template op()>(val, ctx, b, ix); 2147| | } 2148| | // If we skip everything then we may have an extra comma, which we want to revert 2149| | if constexpr (Opts.skip_null_members) { 2150| | if (b[ix - 1] == ',') { 2151| | --ix; 2152| | } 2153| | } 2154| | 2155| | if constexpr (Opts.prettify) { 2156| | ctx.depth -= check_indentation_width(Opts); 2157| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2158| | return; 2159| | } 2160| | std::memcpy(&b[ix], "\n", 1); 2161| | ++ix; 2162| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2163| | ix += ctx.depth; 2164| | std::memcpy(&b[ix], "}", 1); 2165| | ++ix; 2166| | } 2167| | else { 2168| | dump('}', b, ix); 2169| | } 2170| | } 2171| 123| else { 2172| 123| to::template op(val, ctx, b, ix); 2173| 123| } 2174| 123| }, _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm8EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1279| 50| { 1280| 50| static constexpr auto name = name_v>; 1281| 50| constexpr auto n = name.size(); 1282| | 1283| 50| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1283:14): [True: 0, False: 50] ------------------ 1284| 0| return; 1285| 0| } 1286| | 1287| 50| std::memcpy(&b[ix], "\"", 1); 1288| 50| ++ix; 1289| 50| if constexpr (not name.empty()) { 1290| 50| std::memcpy(&b[ix], name.data(), n); 1291| 50| ix += n; 1292| 50| } 1293| 50| std::memcpy(&b[ix], "\"", 1); 1294| 50| ++ix; 1295| 50| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm9EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSC_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1279| 50| { 1280| 50| static constexpr auto name = name_v>; 1281| 50| constexpr auto n = name.size(); 1282| | 1283| 50| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1283:14): [True: 0, False: 50] ------------------ 1284| 0| return; 1285| 0| } 1286| | 1287| 50| std::memcpy(&b[ix], "\"", 1); 1288| 50| ++ix; 1289| 50| if constexpr (not name.empty()) { 1290| 50| std::memcpy(&b[ix], name.data(), n); 1291| 50| ix += n; 1292| 50| } 1293| 50| std::memcpy(&b[ix], "\"", 1); 1294| 50| ++ix; 1295| 50| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm10EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS8_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1279| 50| { 1280| 50| static constexpr auto name = name_v>; 1281| 50| constexpr auto n = name.size(); 1282| | 1283| 50| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1283:14): [True: 0, False: 50] ------------------ 1284| 0| return; 1285| 0| } 1286| | 1287| 50| std::memcpy(&b[ix], "\"", 1); 1288| 50| ++ix; 1289| 50| if constexpr (not name.empty()) { 1290| 50| std::memcpy(&b[ix], name.data(), n); 1291| 50| ix += n; 1292| 50| } 1293| 50| std::memcpy(&b[ix], "\"", 1); 1294| 50| ++ix; 1295| 50| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm11EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEERS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1279| 50| { 1280| 50| static constexpr auto name = name_v>; 1281| 50| constexpr auto n = name.size(); 1282| | 1283| 50| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1283:14): [True: 0, False: 50] ------------------ 1284| 0| return; 1285| 0| } 1286| | 1287| 50| std::memcpy(&b[ix], "\"", 1); 1288| 50| ++ix; 1289| 50| if constexpr (not name.empty()) { 1290| 50| std::memcpy(&b[ix], name.data(), n); 1291| 50| ix += n; 1292| 50| } 1293| 50| std::memcpy(&b[ix], "\"", 1); 1294| 50| ++ix; 1295| 50| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm12EEEDav: 2539| 50| for_each([&]() { 2540| 50| using val_t = field_t; 2541| | 2542| | // `meta::skip` joins the other compile-time exclusions here rather than returning 2543| | // early, so that a skipped field's writer is never instantiated -- see 2544| | // `skipped_by_meta`. 2545| 50| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2546| | if constexpr (skipped_by_meta || always_skipped || 2547| | (!write_function_pointers && is_any_function_ptr)) { 2548| | return; 2549| | } 2550| 50| else { 2551| | if constexpr (meta_has_skip_if) { 2552| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2553| | static constexpr meta_context mctx{.op = operation::serialize}; 2554| | decltype(auto) field_value = [&]() -> decltype(auto) { 2555| | if constexpr (reflectable) { 2556| | return get(t); 2557| | } 2558| | else { 2559| | return get_member(value, glz::get(reflect::values)); 2560| | } 2561| | }(); 2562| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2563| | } 2564| | 2565| | if constexpr (null_t && Opts.skip_null_members) { 2566| | if constexpr (always_null_t) 2567| | return; 2568| | else { 2569| | const auto is_null = [&]() { 2570| | decltype(auto) element = [&]() -> decltype(auto) { 2571| | if constexpr (reflectable) { 2572| | return get(t); 2573| | } 2574| | else { 2575| | return get(reflect::values); 2576| | } 2577| | }; 2578| | 2579| | if constexpr (nullable_wrapper) { 2580| | return !bool(element()(value).val); 2581| | } 2582| | else if constexpr (nullable_value_t) { 2583| | return !get_member(value, element()).has_value(); 2584| | } 2585| | else { 2586| | return !bool(get_member(value, element())); 2587| | } 2588| | }(); 2589| | if (is_null) return; 2590| | } 2591| | } 2592| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2593| | custom_getter_returns_nullable()) { 2594| | if (is_custom_field_null(value, t, ctx)) return; 2595| | } 2596| 50| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2597| 50| if (is_glaze_value_field_null(value, t)) return; 2598| 50| } 2599| | 2600| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2601| | decltype(auto) member = [&]() -> decltype(auto) { 2602| | if constexpr (reflectable) { 2603| | return get_member(value, get(t)); 2604| | } 2605| | else { 2606| | return get_member(value, get(reflect::values)); 2607| | } 2608| | }(); 2609| | if (is_default_value(member)) return; 2610| | } 2611| | 2612| | if constexpr (Opts.prettify) { 2613| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2614| | return; 2615| | } 2616| | } 2617| 50| else { 2618| 50| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2618:29): [True: 0, False: 50] ------------------ 2619| 0| return; 2620| 0| } 2621| 50| } 2622| | 2623| 50| if (first) { ------------------ | Branch (2623:26): [True: 0, False: 50] ------------------ 2624| 0| first = false; 2625| 0| } 2626| 50| else { 2627| | // Null members may be skipped so we can't just write it out for all but the last member 2628| | if constexpr (Opts.prettify) { 2629| | std::memcpy(&b[ix], ",\n", 2); 2630| | ix += 2; 2631| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2632| | ix += ctx.depth; 2633| | } 2634| 50| else { 2635| 50| std::memcpy(&b[ix], ",", 1); 2636| 50| ++ix; 2637| 50| } 2638| | if constexpr (is_output_streaming) { 2639| | flush_buffer(b, ix); 2640| | } 2641| 50| } 2642| | 2643| | // MSVC requires get rather than keys[I] 2644| 50| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2645| 50| static constexpr auto quoted_key = quoted_key_v; 2646| 50| static constexpr auto n = quoted_key.size(); 2647| 50| std::memcpy(&b[ix], quoted_key.data(), n); 2648| 50| ix += n; 2649| | 2650| 50| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2650:57): [Folded, False: 50] ------------------ 2651| 50| if constexpr (reflectable) { 2652| 50| to::template op(get_member(value, get(t)), ctx, b, ix); 2653| | } 2654| | else { 2655| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2656| | ix); 2657| | } 2658| 50| } 2659| 50| }); _ZN3glz2toILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1279| 50| { 1280| 50| static constexpr auto name = name_v>; 1281| 50| constexpr auto n = name.size(); 1282| | 1283| 50| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1283:14): [True: 0, False: 50] ------------------ 1284| 0| return; 1285| 0| } 1286| | 1287| 50| std::memcpy(&b[ix], "\"", 1); 1288| 50| ++ix; 1289| 50| if constexpr (not name.empty()) { 1290| 50| std::memcpy(&b[ix], name.data(), n); 1291| 50| ix += n; 1292| 50| } 1293| 50| std::memcpy(&b[ix], "\"", 1); 1294| 50| ++ix; 1295| 50| } _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 1.91k| { 815| 1.91k| if constexpr (not check_write_unchecked(Opts)) { 816| 1.91k| static_assert(required_padding()); 817| 1.91k| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 1.91k] ------------------ 818| 0| return; 819| 0| } 820| 1.91k| } 821| | 822| 1.91k| static constexpr auto O = write_unchecked_on(); 823| | 824| | if constexpr (check_quoted_num(Opts)) { 825| | std::memcpy(&b[ix], "\"", 1); 826| | ++ix; 827| | write_chars::op(value, ctx, b, ix); 828| | std::memcpy(&b[ix], "\"", 1); 829| | ++ix; 830| | } 831| 1.91k| else { 832| 1.91k| write_chars::op(value, ctx, b, ix); 833| 1.91k| } 834| 1.91k| } _ZN3glz16required_paddingIdEEmv: 538| 1.91k| { 539| 1.91k| constexpr auto value = []() -> size_t { 540| 1.91k| if constexpr (boolean_like) { 541| 1.91k| return 8; 542| 1.91k| } 543| 1.91k| else if constexpr (num_t) { 544| 1.91k| if constexpr (std::floating_point) { 545| 1.91k| if constexpr (sizeof(T) > 8) { 546| 1.91k| return 64; 547| 1.91k| } 548| 1.91k| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 1.91k| return zmij::double_buffer_size + 4; 551| 1.91k| } 552| 1.91k| else { 553| 1.91k| return zmij::float_buffer_size + 4; 554| 1.91k| } 555| 1.91k| } 556| 1.91k| else if constexpr (sizeof(T) > 4) { 557| 1.91k| return 24; 558| 1.91k| } 559| 1.91k| else if constexpr (sizeof(T) > 2) { 560| 1.91k| return 16; 561| 1.91k| } 562| 1.91k| else { 563| 1.91k| return 8; 564| 1.91k| } 565| 1.91k| } 566| 1.91k| else if constexpr (nullable_like) { 567| 1.91k| if constexpr (has_value_type) { 568| 1.91k| return required_padding(); 569| 1.91k| } 570| 1.91k| else if constexpr (has_element_type) { 571| 1.91k| return required_padding(); 572| 1.91k| } 573| 1.91k| else { 574| 1.91k| return 0; 575| 1.91k| } 576| 1.91k| } 577| 1.91k| else if constexpr (always_null_t) { 578| 1.91k| return 8; 579| 1.91k| } 580| 1.91k| else { 581| 1.91k| return 0; 582| 1.91k| } 583| 1.91k| }(); 584| | 585| | if constexpr (value >= (write_padding_bytes - 16)) { 586| | // we always require 16 bytes available from write_padding_bytes 587| | // for opening and closing characters 588| | return 0; 589| | } 590| 1.91k| return value; 591| 1.91k| } _ZN3glz2toILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEEvOT0_OT1_OT2_RT3_: 1805| 48| { 1806| 48| if (value) { ------------------ | Branch (1806:14): [True: 0, False: 48] ------------------ 1807| 0| if constexpr (required_padding()) { 1808| 0| serialize::op(*value, ctx, b, ix); 1809| | } 1810| | else { 1811| | serialize::op()>(*value, ctx, b, ix); 1812| | } 1813| 0| } 1814| 48| else { 1815| 48| dump("null", b, ix); 1816| 48| } 1817| 48| } _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_: 2840| 4.41M| { 2841| 4.41M| return write(std::forward(value)); 2842| 4.41M| } _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 4.41M| { 846| | if constexpr (check_string_as_number(Opts)) { 847| | const sv str = [&]() -> const sv { 848| | if constexpr (array_char_t) { 849| | const auto* start = value.data(); 850| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 851| | return sv{start, end ? size_t(end - start) : value.size()}; 852| | } 853| | else if constexpr (u8str_t) { 854| | return sv{reinterpret_cast(value.data()), value.size()}; 855| | } 856| | else { 857| | return str_view(value); 858| | } 859| | }(); 860| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 861| | return; 862| | } 863| | dump_maybe_empty(str, b, ix); 864| | } 865| | else if constexpr (char_t) { 866| | if constexpr (check_unquoted(Opts)) { 867| | dump(value, b, ix); 868| | } 869| | else { 870| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 871| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 872| | return; 873| | } 874| | 875| | std::memcpy(&b[ix], "\"", 1); 876| | ++ix; 877| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 878| | std::memcpy(&b[ix], &escaped, 2); 879| | ix += 2; 880| | } 881| | else if (value == '\0') { 882| | // null character treated as empty string 883| | } 884| | else if constexpr (check_escape_control_characters(Opts)) { 885| | if (uint8_t(value) < 0x20) { 886| | // Write as \uXXXX format 887| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 888| | constexpr char hex_digits[] = "0123456789ABCDEF"; 889| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 890| | unicode_escape[5] = hex_digits[value & 0xF]; 891| | std::memcpy(&b[ix], unicode_escape, 6); 892| | ix += 6; 893| | } 894| | else { 895| | std::memcpy(&b[ix], &value, 1); 896| | ++ix; 897| | } 898| | } 899| | else { 900| | if constexpr (check_reject_control_characters(Opts)) { 901| | if (uint8_t(value) < 0x20) [[unlikely]] { 902| | ctx.error = error_code::invalid_control_character; 903| | } 904| | } 905| | std::memcpy(&b[ix], &value, 1); 906| | ++ix; 907| | } 908| | std::memcpy(&b[ix], "\"", 1); 909| | ++ix; 910| | } 911| | } 912| 4.41M| else { 913| | if constexpr (check_raw_string(Opts)) { 914| | const sv str = [&]() -> const sv { 915| | if constexpr (u8str_t) { 916| | return sv{reinterpret_cast(value.data()), value.size()}; 917| | } 918| | else { 919| | return str_view(value); 920| | } 921| | }(); 922| | 923| | // We need space for quotes and the string length: 2 + n. 924| | // Use +8 for extra buffer 925| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 926| | return; 927| | } 928| | // now we don't have to check writing 929| | 930| | if constexpr (not check_unquoted(Opts)) { 931| | std::memcpy(&b[ix], "\"", 1); 932| | ++ix; 933| | } 934| | if (str.size()) [[likely]] { 935| | const auto n = str.size(); 936| | std::memcpy(&b[ix], str.data(), n); 937| | ix += n; 938| | } 939| | if constexpr (not check_unquoted(Opts)) { 940| | std::memcpy(&b[ix], "\"", 1); 941| | ++ix; 942| | } 943| | } 944| 4.41M| else { 945| 4.41M| const sv str = [&]() -> const sv { 946| 4.41M| if constexpr (array_char_t) { 947| 4.41M| return sv{value.data(), value.size()}; 948| 4.41M| } 949| 4.41M| else if constexpr (u8str_t) { 950| 4.41M| return sv{reinterpret_cast(value.data()), value.size()}; 951| 4.41M| } 952| 4.41M| else { 953| 4.41M| return str_view(value); 954| 4.41M| } 955| 4.41M| }(); 956| 4.41M| const auto n = str.size(); 957| | 958| | // In the case n == 0 we need two characters for quotes. 959| | // For each individual character we need room for two characters to handle escapes. 960| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 961| | if constexpr (check_escape_control_characters(Opts)) { 962| | if constexpr (has_bounded_capacity) { 963| | // 6 bytes per character is a ceiling only a string of nothing but control 964| | // characters reaches. A resizable buffer merely over-allocates against it, 965| | // but a fixed buffer has nowhere to grow, so the ceiling would reject output 966| | // that fits. Measuring the string answers exactly, at the cost of a pass over 967| | // it, so bracket the measurement between two O(1) bounds and only pay it when 968| | // the answer is still in doubt: the ceiling fitting means yes, and the floor 969| | // of one byte per character not fitting means no. 970| | const size_t capacity = buffer_traits>::capacity(b); 971| | size_t required = ix + 10 + 6 * n; 972| | if (required > capacity) [[unlikely]] { 973| | required = ix + 10 + n; 974| | if (required <= capacity) { 975| | required = ix + 10 + detail::escaped_string_size(str); 976| | } 977| | } 978| | if (!ensure_space(ctx, b, required)) [[unlikely]] { 979| | return; 980| | } 981| | } 982| | // We need 2 + 6 * n characters in the worst case (all control chars) 983| | else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 984| | return; 985| | } 986| | } 987| 4.41M| else { 988| | // Using the original sizing 989| 4.41M| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 4.41M] ------------------ 990| 0| return; 991| 0| } 992| 4.41M| } 993| | // now we don't have to check writing 994| | 995| | if constexpr (check_unquoted(Opts)) { 996| | if (n) { 997| | std::memcpy(&b[ix], str.data(), n); 998| | ix += n; 999| | } 1000| | } 1001| 4.41M| else { 1002| 4.41M| std::memcpy(&b[ix], "\"", 1); 1003| 4.41M| ++ix; 1004| | 1005| 4.41M| const auto* c = str.data(); 1006| 4.41M| const auto* const e = c + n; 1007| 4.41M| const auto start = &b[ix]; 1008| 4.41M| auto data = start; 1009| | 1010| | // By default we don't escape control characters for performance. Invalid JSON characters 1011| | // result in null characters in the output, making the JSON invalid — these would then be 1012| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 1013| | // control characters (0x00–0x1F) as \uXXXX sequences. 1014| | 1015| | // Escape handler: writes the escaped form of *c into data, advances both pointers 1016| 4.41M| auto write_escape = [&]() { 1017| 4.41M| if constexpr (check_escape_control_characters(Opts)) { 1018| 4.41M| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 4.41M| std::memcpy(data, &escaped, 2); 1020| 4.41M| data += 2; 1021| 4.41M| } 1022| 4.41M| else { 1023| 4.41M| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 4.41M| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 4.41M| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 4.41M| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 4.41M| std::memcpy(data, unicode_escape, 6); 1028| 4.41M| data += 6; 1029| 4.41M| } 1030| 4.41M| } 1031| 4.41M| else { 1032| 4.41M| if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| 4.41M| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 4.41M| ctx.error = error_code::invalid_control_character; 1040| 4.41M| } 1041| 4.41M| } 1042| 4.41M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 4.41M| data += 2; 1044| 4.41M| } 1045| 4.41M| ++c; 1046| 4.41M| }; 1047| | 1048| | // Adding a helper here means adding a branch to string_escape_simd() in 1049| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 1050| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 1051| |#if defined(GLZ_USE_AVX2) 1052| | detail::avx2_string_escape(c, e, data, n, write_escape); 1053| |#endif 1054| 4.41M|#if defined(GLZ_USE_SSE2) 1055| 4.41M| detail::sse2_string_escape(c, e, data, n, write_escape); 1056| |#elif defined(GLZ_USE_NEON) 1057| | detail::neon_string_escape(c, e, data, n, write_escape); 1058| |#endif 1059| | 1060| | // SWAR: 8 bytes at a time 1061| 4.41M| if (n > 7) { ------------------ | Branch (1061:23): [True: 4.41M, False: 0] ------------------ 1062| 4.91M| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 500k, False: 4.41M] ------------------ 1063| 500k| std::memcpy(data, c, 8); 1064| 500k| uint64_t swar; 1065| 500k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 500k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 500k| const uint64_t lo7 = swar & lo7_mask; 1072| 500k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 500k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 500k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 500k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 500k| next &= repeat_byte8(0b10000000); 1078| 500k| if (next == 0) { ------------------ | Branch (1078:29): [True: 41.0k, False: 459k] ------------------ 1079| 41.0k| data += 8; 1080| 41.0k| c += 8; 1081| 41.0k| continue; 1082| 41.0k| } 1083| | 1084| 459k| const auto length = (countr_zero(next) >> 3); 1085| 459k| c += length; 1086| 459k| data += length; 1087| 459k| write_escape(); 1088| 459k| } 1089| 4.41M| } 1090| | 1091| | // Scalar tail 1092| 30.3M| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 25.9M, False: 4.41M] ------------------ 1093| 25.9M| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 51.4k, False: 25.8M] ------------------ 1094| 51.4k| std::memcpy(data, &escaped, 2); 1095| 51.4k| data += 2; 1096| 51.4k| } 1097| | else if constexpr (check_escape_control_characters(Opts)) { 1098| | if (uint8_t(*c) < 0x20) { 1099| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1100| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1101| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1102| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1103| | std::memcpy(data, unicode_escape, 6); 1104| | data += 6; 1105| | } 1106| | else { 1107| | std::memcpy(data, c, 1); 1108| | ++data; 1109| | } 1110| | } 1111| 25.8M| else { 1112| | if constexpr (check_reject_control_characters(Opts)) { 1113| | if (uint8_t(*c) < 0x20) [[unlikely]] { 1114| | ctx.error = error_code::invalid_control_character; 1115| | } 1116| | } 1117| 25.8M| std::memcpy(data, c, 1); 1118| 25.8M| ++data; 1119| 25.8M| } 1120| 25.9M| } 1121| | 1122| 4.41M| ix += size_t(data - start); 1123| | 1124| 4.41M| std::memcpy(&b[ix], "\"", 1); 1125| 4.41M| ++ix; 1126| 4.41M| } 1127| 4.41M| } 1128| 4.41M| } 1129| 4.41M| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 4.41M| const sv str = [&]() -> const sv { 946| | if constexpr (array_char_t) { 947| | return sv{value.data(), value.size()}; 948| | } 949| | else if constexpr (u8str_t) { 950| | return sv{reinterpret_cast(value.data()), value.size()}; 951| | } 952| 4.41M| else { 953| 4.41M| return str_view(value); 954| 4.41M| } 955| 4.41M| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 1.26M| auto write_escape = [&]() { 1017| | if constexpr (check_escape_control_characters(Opts)) { 1018| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| | std::memcpy(data, &escaped, 2); 1020| | data += 2; 1021| | } 1022| | else { 1023| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| | std::memcpy(data, unicode_escape, 6); 1028| | data += 6; 1029| | } 1030| | } 1031| 1.26M| else { 1032| | if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| | if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| | ctx.error = error_code::invalid_control_character; 1040| | } 1041| | } 1042| 1.26M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 1.26M| data += 2; 1044| 1.26M| } 1045| 1.26M| ++c; 1046| 1.26M| }; _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_: 2840| 37| { 2841| 37| return write(std::forward(value)); 2842| 37| } _ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 37| { 846| | if constexpr (check_string_as_number(Opts)) { 847| | const sv str = [&]() -> const sv { 848| | if constexpr (array_char_t) { 849| | const auto* start = value.data(); 850| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 851| | return sv{start, end ? size_t(end - start) : value.size()}; 852| | } 853| | else if constexpr (u8str_t) { 854| | return sv{reinterpret_cast(value.data()), value.size()}; 855| | } 856| | else { 857| | return str_view(value); 858| | } 859| | }(); 860| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 861| | return; 862| | } 863| | dump_maybe_empty(str, b, ix); 864| | } 865| | else if constexpr (char_t) { 866| | if constexpr (check_unquoted(Opts)) { 867| | dump(value, b, ix); 868| | } 869| | else { 870| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 871| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 872| | return; 873| | } 874| | 875| | std::memcpy(&b[ix], "\"", 1); 876| | ++ix; 877| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 878| | std::memcpy(&b[ix], &escaped, 2); 879| | ix += 2; 880| | } 881| | else if (value == '\0') { 882| | // null character treated as empty string 883| | } 884| | else if constexpr (check_escape_control_characters(Opts)) { 885| | if (uint8_t(value) < 0x20) { 886| | // Write as \uXXXX format 887| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 888| | constexpr char hex_digits[] = "0123456789ABCDEF"; 889| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 890| | unicode_escape[5] = hex_digits[value & 0xF]; 891| | std::memcpy(&b[ix], unicode_escape, 6); 892| | ix += 6; 893| | } 894| | else { 895| | std::memcpy(&b[ix], &value, 1); 896| | ++ix; 897| | } 898| | } 899| | else { 900| | if constexpr (check_reject_control_characters(Opts)) { 901| | if (uint8_t(value) < 0x20) [[unlikely]] { 902| | ctx.error = error_code::invalid_control_character; 903| | } 904| | } 905| | std::memcpy(&b[ix], &value, 1); 906| | ++ix; 907| | } 908| | std::memcpy(&b[ix], "\"", 1); 909| | ++ix; 910| | } 911| | } 912| 37| else { 913| | if constexpr (check_raw_string(Opts)) { 914| | const sv str = [&]() -> const sv { 915| | if constexpr (u8str_t) { 916| | return sv{reinterpret_cast(value.data()), value.size()}; 917| | } 918| | else { 919| | return str_view(value); 920| | } 921| | }(); 922| | 923| | // We need space for quotes and the string length: 2 + n. 924| | // Use +8 for extra buffer 925| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 926| | return; 927| | } 928| | // now we don't have to check writing 929| | 930| | if constexpr (not check_unquoted(Opts)) { 931| | std::memcpy(&b[ix], "\"", 1); 932| | ++ix; 933| | } 934| | if (str.size()) [[likely]] { 935| | const auto n = str.size(); 936| | std::memcpy(&b[ix], str.data(), n); 937| | ix += n; 938| | } 939| | if constexpr (not check_unquoted(Opts)) { 940| | std::memcpy(&b[ix], "\"", 1); 941| | ++ix; 942| | } 943| | } 944| 37| else { 945| 37| const sv str = [&]() -> const sv { 946| 37| if constexpr (array_char_t) { 947| 37| return sv{value.data(), value.size()}; 948| 37| } 949| 37| else if constexpr (u8str_t) { 950| 37| return sv{reinterpret_cast(value.data()), value.size()}; 951| 37| } 952| 37| else { 953| 37| return str_view(value); 954| 37| } 955| 37| }(); 956| 37| const auto n = str.size(); 957| | 958| | // In the case n == 0 we need two characters for quotes. 959| | // For each individual character we need room for two characters to handle escapes. 960| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 961| | if constexpr (check_escape_control_characters(Opts)) { 962| | if constexpr (has_bounded_capacity) { 963| | // 6 bytes per character is a ceiling only a string of nothing but control 964| | // characters reaches. A resizable buffer merely over-allocates against it, 965| | // but a fixed buffer has nowhere to grow, so the ceiling would reject output 966| | // that fits. Measuring the string answers exactly, at the cost of a pass over 967| | // it, so bracket the measurement between two O(1) bounds and only pay it when 968| | // the answer is still in doubt: the ceiling fitting means yes, and the floor 969| | // of one byte per character not fitting means no. 970| | const size_t capacity = buffer_traits>::capacity(b); 971| | size_t required = ix + 10 + 6 * n; 972| | if (required > capacity) [[unlikely]] { 973| | required = ix + 10 + n; 974| | if (required <= capacity) { 975| | required = ix + 10 + detail::escaped_string_size(str); 976| | } 977| | } 978| | if (!ensure_space(ctx, b, required)) [[unlikely]] { 979| | return; 980| | } 981| | } 982| | // We need 2 + 6 * n characters in the worst case (all control chars) 983| | else if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 984| | return; 985| | } 986| | } 987| 37| else { 988| | // Using the original sizing 989| 37| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 37] ------------------ 990| 0| return; 991| 0| } 992| 37| } 993| | // now we don't have to check writing 994| | 995| | if constexpr (check_unquoted(Opts)) { 996| | if (n) { 997| | std::memcpy(&b[ix], str.data(), n); 998| | ix += n; 999| | } 1000| | } 1001| 37| else { 1002| 37| std::memcpy(&b[ix], "\"", 1); 1003| 37| ++ix; 1004| | 1005| 37| const auto* c = str.data(); 1006| 37| const auto* const e = c + n; 1007| 37| const auto start = &b[ix]; 1008| 37| auto data = start; 1009| | 1010| | // By default we don't escape control characters for performance. Invalid JSON characters 1011| | // result in null characters in the output, making the JSON invalid — these would then be 1012| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 1013| | // control characters (0x00–0x1F) as \uXXXX sequences. 1014| | 1015| | // Escape handler: writes the escaped form of *c into data, advances both pointers 1016| 37| auto write_escape = [&]() { 1017| 37| if constexpr (check_escape_control_characters(Opts)) { 1018| 37| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 37| std::memcpy(data, &escaped, 2); 1020| 37| data += 2; 1021| 37| } 1022| 37| else { 1023| 37| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 37| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 37| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 37| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 37| std::memcpy(data, unicode_escape, 6); 1028| 37| data += 6; 1029| 37| } 1030| 37| } 1031| 37| else { 1032| 37| if constexpr (check_reject_control_characters(Opts)) { 1033| | // A control character with no two-character escape cannot be written 1034| | // without \uXXXX. The table entry is zero, so the memcpy below would 1035| | // put two NULs where one byte was. Flag it and let the loop finish: 1036| | // returning early here would leave c un-advanced and the SIMD scan 1037| | // would find the same byte forever. The output is abandoned anyway. 1038| 37| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 37| ctx.error = error_code::invalid_control_character; 1040| 37| } 1041| 37| } 1042| 37| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 37| data += 2; 1044| 37| } 1045| 37| ++c; 1046| 37| }; 1047| | 1048| | // Adding a helper here means adding a branch to string_escape_simd() in 1049| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 1050| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 1051| |#if defined(GLZ_USE_AVX2) 1052| | detail::avx2_string_escape(c, e, data, n, write_escape); 1053| |#endif 1054| 37|#if defined(GLZ_USE_SSE2) 1055| 37| detail::sse2_string_escape(c, e, data, n, write_escape); 1056| |#elif defined(GLZ_USE_NEON) 1057| | detail::neon_string_escape(c, e, data, n, write_escape); 1058| |#endif 1059| | 1060| | // SWAR: 8 bytes at a time 1061| 37| if (n > 7) { ------------------ | Branch (1061:23): [True: 0, False: 37] ------------------ 1062| 0| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 0, False: 0] ------------------ 1063| 0| std::memcpy(data, c, 8); 1064| 0| uint64_t swar; 1065| 0| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 0| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 0| const uint64_t lo7 = swar & lo7_mask; 1072| 0| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 0| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 0| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 0| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 0| next &= repeat_byte8(0b10000000); 1078| 0| if (next == 0) { ------------------ | Branch (1078:29): [True: 0, False: 0] ------------------ 1079| 0| data += 8; 1080| 0| c += 8; 1081| 0| continue; 1082| 0| } 1083| | 1084| 0| const auto length = (countr_zero(next) >> 3); 1085| 0| c += length; 1086| 0| data += length; 1087| 0| write_escape(); 1088| 0| } 1089| 0| } 1090| | 1091| | // Scalar tail 1092| 259| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 222, False: 37] ------------------ 1093| 222| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 0, False: 222] ------------------ 1094| 0| std::memcpy(data, &escaped, 2); 1095| 0| data += 2; 1096| 0| } 1097| | else if constexpr (check_escape_control_characters(Opts)) { 1098| | if (uint8_t(*c) < 0x20) { 1099| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1100| | constexpr char hex_digits[] = "0123456789ABCDEF"; 1101| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1102| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1103| | std::memcpy(data, unicode_escape, 6); 1104| | data += 6; 1105| | } 1106| | else { 1107| | std::memcpy(data, c, 1); 1108| | ++data; 1109| | } 1110| | } 1111| 222| else { 1112| | if constexpr (check_reject_control_characters(Opts)) { 1113| | if (uint8_t(*c) < 0x20) [[unlikely]] { 1114| | ctx.error = error_code::invalid_control_character; 1115| | } 1116| | } 1117| 222| std::memcpy(data, c, 1); 1118| 222| ++data; 1119| 222| } 1120| 222| } 1121| | 1122| 37| ix += size_t(data - start); 1123| | 1124| 37| std::memcpy(&b[ix], "\"", 1); 1125| 37| ++ix; 1126| 37| } 1127| 37| } 1128| 37| } 1129| 37| } _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 37| const sv str = [&]() -> const sv { 946| | if constexpr (array_char_t) { 947| | return sv{value.data(), value.size()}; 948| | } 949| | else if constexpr (u8str_t) { 950| | return sv{reinterpret_cast(value.data()), value.size()}; 951| | } 952| 37| else { 953| 37| return str_view(value); 954| 37| } 955| 37| }(); _ZN3glz6to_tieIRN12jsonrpc_fuzz5pointELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 74.5k| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| | else if constexpr (N == 1) { 142| | auto& [p] = t; 143| | return glz::tie(p); 144| | } 145| 74.5k| else if constexpr (N == 2) { 146| 74.5k| auto& [p0, p1] = t; 147| 74.5k| return glz::tie(p0, p1); 148| | } 149| | else if constexpr (N == 3) { 150| | auto& [p0, p1, p2] = t; 151| | return glz::tie(p0, p1, p2); 152| | } 153| | else if constexpr (N == 4) { 154| | auto& [p0, p1, p2, p3] = t; 155| | return glz::tie(p0, p1, p2, p3); 156| | } 157| | else if constexpr (N == 5) { 158| | auto& [p0, p1, p2, p3, p4] = t; 159| | return glz::tie(p0, p1, p2, p3, p4); 160| | } 161| | else if constexpr (N == 6) { 162| | auto& [p0, p1, p2, p3, p4, p5] = t; 163| | return glz::tie(p0, p1, p2, p3, p4, p5); 164| | } 165| | else if constexpr (N == 7) { 166| | auto& [p0, p1, p2, p3, p4, p5, p6] = t; 167| | return glz::tie(p0, p1, p2, p3, p4, p5, p6); 168| | } 169| | else if constexpr (N == 8) { 170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t; 171| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7); 172| | } 173| | else if constexpr (N == 9) { 174| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t; 175| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8); 176| | } 177| | else if constexpr (N == 10) { 178| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t; 179| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 180| | } 181| | else if constexpr (N == 11) { 182| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t; 183| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); 184| | } 185| | else if constexpr (N == 12) { 186| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t; 187| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); 188| | } 189| | else if constexpr (N == 13) { 190| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); 192| | } 193| | else if constexpr (N == 14) { 194| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t; 195| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); 196| | } 197| | else if constexpr (N == 15) { 198| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t; 199| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); 200| | } 201| | else if constexpr (N == 16) { 202| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t; 203| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); 204| | } 205| | else if constexpr (N == 17) { 206| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t; 207| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); 208| | } 209| | else if constexpr (N == 18) { 210| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t; 211| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); 212| | } 213| | else if constexpr (N == 19) { 214| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t; 215| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); 216| | } 217| | else if constexpr (N == 20) { 218| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t; 219| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); 220| | } 221| | else if constexpr (N == 21) { 222| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t; 223| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); 224| | } 225| | else if constexpr (N == 22) { 226| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t; 227| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 228| | p21); 229| | } 230| | else if constexpr (N == 23) { 231| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, 232| | p22] = t; 233| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 234| | p21, p22); 235| | } 236| | else if constexpr (N == 24) { 237| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 238| | p23] = t; 239| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 240| | p21, p22, p23); 241| | } 242| | else if constexpr (N == 25) { 243| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 244| | p23, p24] = t; 245| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 246| | p21, p22, p23, p24); 247| | } 248| | else if constexpr (N == 26) { 249| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 250| | p23, p24, p25] = t; 251| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 252| | p21, p22, p23, p24, p25); 253| | } 254| | else if constexpr (N == 27) { 255| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 256| | p23, p24, p25, p26] = t; 257| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 258| | p21, p22, p23, p24, p25, p26); 259| | } 260| | else if constexpr (N == 28) { 261| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 262| | p23, p24, p25, p26, p27] = t; 263| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 264| | p21, p22, p23, p24, p25, p26, p27); 265| | } 266| | else if constexpr (N == 29) { 267| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 268| | p23, p24, p25, p26, p27, p28] = t; 269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 270| | p21, p22, p23, p24, p25, p26, p27, p28); 271| | } 272| | else if constexpr (N == 30) { 273| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 274| | p23, p24, p25, p26, p27, p28, p29] = t; 275| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 276| | p21, p22, p23, p24, p25, p26, p27, p28, p29); 277| | } 278| | else if constexpr (N == 31) { 279| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 280| | p23, p24, p25, p26, p27, p28, p29, p30] = t; 281| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 282| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30); 283| | } 284| | else if constexpr (N == 32) { 285| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 286| | p23, p24, p25, p26, p27, p28, p29, p30, p31] = t; 287| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 288| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31); 289| | } 290| | else if constexpr (N == 33) { 291| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 292| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t; 293| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 294| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32); 295| | } 296| | else if constexpr (N == 34) { 297| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 298| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t; 299| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 300| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33); 301| | } 302| | else if constexpr (N == 35) { 303| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 304| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t; 305| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 306| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34); 307| | } 308| | else if constexpr (N == 36) { 309| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 310| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t; 311| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 312| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35); 313| | } 314| | else if constexpr (N == 37) { 315| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 316| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t; 317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36); 319| | } 320| | else if constexpr (N == 38) { 321| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 322| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t; 323| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 324| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37); 325| | } 326| | else if constexpr (N == 39) { 327| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 328| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t; 329| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 330| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38); 331| | } 332| | else if constexpr (N == 40) { 333| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 334| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t; 335| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 336| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39); 337| | } 338| | else if constexpr (N == 41) { 339| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 340| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t; 341| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 342| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 343| | p40); 344| | } 345| | else if constexpr (N == 42) { 346| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 347| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t; 348| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 349| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 350| | p40, p41); 351| | } 352| | else if constexpr (N == 43) { 353| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 354| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t; 355| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 356| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 357| | p40, p41, p42); 358| | } 359| | else if constexpr (N == 44) { 360| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 361| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, 362| | p43] = t; 363| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 364| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 365| | p40, p41, p42, p43); 366| | } 367| | else if constexpr (N == 45) { 368| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 369| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 370| | p44] = t; 371| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 372| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 373| | p40, p41, p42, p43, p44); 374| | } 375| | else if constexpr (N == 46) { 376| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 377| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 378| | p44, p45] = t; 379| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 380| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 381| | p40, p41, p42, p43, p44, p45); 382| | } 383| | else if constexpr (N == 47) { 384| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 385| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 386| | p44, p45, p46] = t; 387| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 388| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 389| | p40, p41, p42, p43, p44, p45, p46); 390| | } 391| | else if constexpr (N == 48) { 392| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 393| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 394| | p44, p45, p46, p47] = t; 395| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 396| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 397| | p40, p41, p42, p43, p44, p45, p46, p47); 398| | } 399| | else if constexpr (N == 49) { 400| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 401| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 402| | p44, p45, p46, p47, p48] = t; 403| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 404| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 405| | p40, p41, p42, p43, p44, p45, p46, p47, p48); 406| | } 407| | else if constexpr (N == 50) { 408| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 409| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 410| | p44, p45, p46, p47, p48, p49] = t; 411| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 412| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 413| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49); 414| | } 415| | else if constexpr (N == 51) { 416| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 417| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 418| | p44, p45, p46, p47, p48, p49, p50] = t; 419| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 420| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 421| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50); 422| | } 423| | else if constexpr (N == 52) { 424| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 425| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 426| | p44, p45, p46, p47, p48, p49, p50, p51] = t; 427| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 428| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 429| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51); 430| | } 431| | else if constexpr (N == 53) { 432| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 433| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 434| | p44, p45, p46, p47, p48, p49, p50, p51, p52] = t; 435| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 436| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 437| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52); 438| | } 439| | else if constexpr (N == 54) { 440| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 441| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 442| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t; 443| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 444| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 445| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53); 446| | } 447| | else if constexpr (N == 55) { 448| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 449| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 450| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t; 451| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 452| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 453| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54); 454| | } 455| | else if constexpr (N == 56) { 456| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 457| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 458| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t; 459| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 460| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 461| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55); 462| | } 463| | else if constexpr (N == 57) { 464| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 465| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 466| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t; 467| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 468| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 469| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56); 470| | } 471| | else if constexpr (N == 58) { 472| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 473| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 474| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t; 475| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 476| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 477| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57); 478| | } 479| | else if constexpr (N == 59) { 480| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 481| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 482| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t; 483| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 484| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 485| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58); 486| | } 487| | else if constexpr (N == 60) { 488| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 489| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 490| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t; 491| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 492| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 493| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 494| | p59); 495| | } 496| | else if constexpr (N == 61) { 497| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 498| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 499| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t; 500| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 501| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 502| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 503| | p59, p60); 504| | } 505| | else if constexpr (N == 62) { 506| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 507| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 508| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t; 509| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 510| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 511| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 512| | p59, p60, p61); 513| | } 514| | else if constexpr (N == 63) { 515| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 516| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 517| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t; 518| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 519| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 520| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 521| | p59, p60, p61, p62); 522| | } 523| | else if constexpr (N == 64) { 524| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 525| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 526| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t; 527| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 528| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 529| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 530| | p59, p60, p61, p62, p63); 531| | } 532| | else if constexpr (N == 65) { 533| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 534| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 535| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, 536| | p64] = t; 537| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 538| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 539| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 540| | p59, p60, p61, p62, p63, p64); 541| | } 542| | else if constexpr (N == 66) { 543| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 544| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 545| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 546| | p65] = t; 547| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 548| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 549| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 550| | p59, p60, p61, p62, p63, p64, p65); 551| | } 552| | else if constexpr (N == 67) { 553| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 554| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 555| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 556| | p65, p66] = t; 557| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 558| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 559| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 560| | p59, p60, p61, p62, p63, p64, p65, p66); 561| | } 562| | else if constexpr (N == 68) { 563| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 564| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 565| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 566| | p65, p66, p67] = t; 567| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 568| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 569| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 570| | p59, p60, p61, p62, p63, p64, p65, p66, p67); 571| | } 572| | else if constexpr (N == 69) { 573| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 574| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 575| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 576| | p65, p66, p67, p68] = t; 577| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 578| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 579| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 580| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68); 581| | } 582| | else if constexpr (N == 70) { 583| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 584| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 585| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 586| | p65, p66, p67, p68, p69] = t; 587| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 588| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 589| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 590| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69); 591| | } 592| | else if constexpr (N == 71) { 593| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 594| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 595| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 596| | p65, p66, p67, p68, p69, p70] = t; 597| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 598| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 599| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 600| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70); 601| | } 602| | else if constexpr (N == 72) { 603| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 604| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 605| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 606| | p65, p66, p67, p68, p69, p70, p71] = t; 607| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 608| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 609| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 610| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71); 611| | } 612| | else if constexpr (N == 73) { 613| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 614| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 615| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 616| | p65, p66, p67, p68, p69, p70, p71, p72] = t; 617| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 618| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 619| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 620| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72); 621| | } 622| | else if constexpr (N == 74) { 623| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 624| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 625| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 626| | p65, p66, p67, p68, p69, p70, p71, p72, p73] = t; 627| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 628| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 629| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 630| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73); 631| | } 632| | else if constexpr (N == 75) { 633| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 634| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 635| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 636| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t; 637| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 638| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 639| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 640| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74); 641| | } 642| | else if constexpr (N == 76) { 643| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 644| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 645| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 646| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t; 647| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 648| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 649| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 650| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75); 651| | } 652| | else if constexpr (N == 77) { 653| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 654| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 655| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 656| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t; 657| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 658| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 659| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 660| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76); 661| | } 662| | else if constexpr (N == 78) { 663| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 664| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 665| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 666| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t; 667| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 668| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 669| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 670| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77); 671| | } 672| | else if constexpr (N == 79) { 673| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 674| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 675| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 676| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t; 677| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 678| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 679| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 680| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 681| | p78); 682| | } 683| | else if constexpr (N == 80) { 684| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 685| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 686| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 687| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t; 688| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 689| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 690| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 691| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 692| | p78, p79); 693| | } 694| | else if constexpr (N == 81) { 695| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 696| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 697| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 698| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t; 699| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 700| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 701| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 702| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 703| | p78, p79, p80); 704| | } 705| | else if constexpr (N == 82) { 706| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 707| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 708| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 709| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t; 710| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 711| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 712| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 713| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 714| | p78, p79, p80, p81); 715| | } 716| | else if constexpr (N == 83) { 717| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 718| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 719| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 720| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t; 721| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 722| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 723| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 724| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 725| | p78, p79, p80, p81, p82); 726| | } 727| | else if constexpr (N == 84) { 728| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 729| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 730| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 731| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t; 732| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 733| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 734| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 735| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 736| | p78, p79, p80, p81, p82, p83); 737| | } 738| | else if constexpr (N == 85) { 739| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 740| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 741| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 742| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t; 743| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 744| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 745| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 746| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 747| | p78, p79, p80, p81, p82, p83, p84); 748| | } 749| | else if constexpr (N == 86) { 750| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 751| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 752| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 753| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, 754| | p85] = t; 755| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 756| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 757| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 758| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 759| | p78, p79, p80, p81, p82, p83, p84, p85); 760| | } 761| | else if constexpr (N == 87) { 762| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 763| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 764| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 765| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 766| | p86] = t; 767| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 768| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 769| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 770| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 771| | p78, p79, p80, p81, p82, p83, p84, p85, p86); 772| | } 773| | else if constexpr (N == 88) { 774| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 775| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 776| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 777| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 778| | p86, p87] = t; 779| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 780| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 781| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 782| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 783| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87); 784| | } 785| | else if constexpr (N == 89) { 786| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 787| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 788| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 789| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 790| | p86, p87, p88] = t; 791| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 792| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 793| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 794| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 795| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88); 796| | } 797| | else if constexpr (N == 90) { 798| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 799| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 800| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 801| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 802| | p86, p87, p88, p89] = t; 803| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 804| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 805| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 806| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 807| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89); 808| | } 809| | else if constexpr (N == 91) { 810| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 811| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 812| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 813| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 814| | p86, p87, p88, p89, p90] = t; 815| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 816| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 817| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 818| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 819| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90); 820| | } 821| | else if constexpr (N == 92) { 822| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 823| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 824| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 825| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 826| | p86, p87, p88, p89, p90, p91] = t; 827| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 828| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 829| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 830| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 831| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91); 832| | } 833| | else if constexpr (N == 93) { 834| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 835| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 836| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 837| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 838| | p86, p87, p88, p89, p90, p91, p92] = t; 839| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 840| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 841| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 842| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 843| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92); 844| | } 845| | else if constexpr (N == 94) { 846| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 847| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 848| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 849| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 850| | p86, p87, p88, p89, p90, p91, p92, p93] = t; 851| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 852| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 853| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 854| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 855| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93); 856| | } 857| | else if constexpr (N == 95) { 858| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 859| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 860| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 861| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 862| | p86, p87, p88, p89, p90, p91, p92, p93, p94] = t; 863| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 864| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 865| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 866| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 867| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94); 868| | } 869| | else if constexpr (N == 96) { 870| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 871| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 872| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 873| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 874| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t; 875| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 876| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 877| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 878| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 879| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95); 880| | } 881| | else if constexpr (N == 97) { 882| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 883| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 884| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 885| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 886| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t; 887| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 888| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 889| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 890| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 891| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96); 892| | } 893| | else if constexpr (N == 98) { 894| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 895| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 896| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 897| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 898| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t; 899| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 900| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 901| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 902| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 903| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 904| | p97); 905| | } 906| | else if constexpr (N == 99) { 907| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 908| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 909| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 910| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 911| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t; 912| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 913| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 914| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 915| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 916| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 917| | p97, p98); 918| | } 919| | else if constexpr (N == 100) { 920| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 921| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 922| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 923| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 924| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t; 925| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 926| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 927| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 928| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 929| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 930| | p97, p98, p99); 931| | } 932| | else if constexpr (N == 101) { 933| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 934| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 935| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 936| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 937| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t; 938| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 939| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 940| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 941| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 942| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 943| | p97, p98, p99, p100); 944| | } 945| | else if constexpr (N == 102) { 946| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 947| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 948| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 949| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 950| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t; 951| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 952| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 953| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 954| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 955| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 956| | p97, p98, p99, p100, p101); 957| | } 958| | else if constexpr (N == 103) { 959| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 960| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 961| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 962| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 963| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t; 964| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 965| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 966| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 967| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 968| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 969| | p97, p98, p99, p100, p101, p102); 970| | } 971| | else if constexpr (N == 104) { 972| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 973| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 974| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 975| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 976| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t; 977| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 978| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 979| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 980| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 981| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 982| | p97, p98, p99, p100, p101, p102, p103); 983| | } 984| | else if constexpr (N == 105) { 985| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 986| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 987| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 988| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 989| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t; 990| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 991| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 992| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 993| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 994| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 995| | p97, p98, p99, p100, p101, p102, p103, p104); 996| | } 997| | else if constexpr (N == 106) { 998| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 999| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1000| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1001| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1002| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1003| | p105] = t; 1004| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1005| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1006| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1007| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1008| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1009| | p97, p98, p99, p100, p101, p102, p103, p104, p105); 1010| | } 1011| | else if constexpr (N == 107) { 1012| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1013| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1014| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1015| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1016| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1017| | p105, p106] = t; 1018| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1019| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1020| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1021| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1022| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1023| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106); 1024| | } 1025| | else if constexpr (N == 108) { 1026| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1027| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1028| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1029| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1030| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1031| | p105, p106, p107] = t; 1032| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1033| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1034| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1035| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1036| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1037| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107); 1038| | } 1039| | else if constexpr (N == 109) { 1040| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1041| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1042| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1043| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1044| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1045| | p105, p106, p107, p108] = t; 1046| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1047| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1048| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1049| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1050| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1051| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108); 1052| | } 1053| | else if constexpr (N == 110) { 1054| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1055| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1056| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1057| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1058| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1059| | p105, p106, p107, p108, p109] = t; 1060| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1061| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1062| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1063| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1064| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1065| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109); 1066| | } 1067| | else if constexpr (N == 111) { 1068| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1069| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1070| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1071| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1072| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1073| | p105, p106, p107, p108, p109, p110] = t; 1074| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1075| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1076| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1077| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1078| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1079| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110); 1080| | } 1081| | else if constexpr (N == 112) { 1082| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1083| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1084| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1085| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1086| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1087| | p105, p106, p107, p108, p109, p110, p111] = t; 1088| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1089| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1090| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1091| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1092| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1093| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111); 1094| | } 1095| | else if constexpr (N == 113) { 1096| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1097| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1098| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1099| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1100| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1101| | p105, p106, p107, p108, p109, p110, p111, p112] = t; 1102| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1103| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1104| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1105| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1106| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1107| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112); 1108| | } 1109| | else if constexpr (N == 114) { 1110| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1111| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1112| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1113| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1114| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1115| | p105, p106, p107, p108, p109, p110, p111, p112, p113] = t; 1116| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1117| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1118| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1119| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1120| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1121| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1122| | p113); 1123| | } 1124| | else if constexpr (N == 115) { 1125| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1126| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1127| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1128| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1129| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1130| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t; 1131| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1132| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1133| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1134| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1135| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1136| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1137| | p113, p114); 1138| | } 1139| | else if constexpr (N == 116) { 1140| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1141| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1142| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1143| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1144| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1145| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t; 1146| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1147| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1148| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1149| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1150| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1151| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1152| | p113, p114, p115); 1153| | } 1154| | else if constexpr (N == 117) { 1155| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1156| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1157| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1158| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1159| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1160| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t; 1161| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1162| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1163| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1164| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1165| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1166| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1167| | p113, p114, p115, p116); 1168| | } 1169| | else if constexpr (N == 118) { 1170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1171| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1172| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1173| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1174| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1175| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t; 1176| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1177| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1178| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1179| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1180| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1181| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1182| | p113, p114, p115, p116, p117); 1183| | } 1184| | else if constexpr (N == 119) { 1185| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1186| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1187| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1188| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1189| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1190| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t; 1191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1192| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1193| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1194| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1195| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1196| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1197| | p113, p114, p115, p116, p117, p118); 1198| | } 1199| | else if constexpr (N == 120) { 1200| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1201| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1202| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1203| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1204| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1205| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t; 1206| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1207| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1208| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1209| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1210| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1211| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1212| | p113, p114, p115, p116, p117, p118, p119); 1213| | } 1214| | else if constexpr (N == 121) { 1215| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1216| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1217| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1218| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1219| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1220| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t; 1221| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1222| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1223| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1224| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1225| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1226| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1227| | p113, p114, p115, p116, p117, p118, p119, p120); 1228| | } 1229| | else if constexpr (N == 122) { 1230| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1231| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1232| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1233| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1234| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1235| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] = 1236| | t; 1237| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1238| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1239| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1240| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1241| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1242| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1243| | p113, p114, p115, p116, p117, p118, p119, p120, p121); 1244| | } 1245| | else if constexpr (N == 123) { 1246| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1247| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1248| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1249| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1250| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1251| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1252| | p122] = t; 1253| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1254| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1255| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1256| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1257| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1258| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1259| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122); 1260| | } 1261| | else if constexpr (N == 124) { 1262| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1263| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1264| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1265| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1266| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1267| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1268| | p122, p123] = t; 1269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1270| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1271| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1272| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1273| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1274| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1275| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123); 1276| | } 1277| | else if constexpr (N == 125) { 1278| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1279| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1280| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1281| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1282| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1283| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1284| | p122, p123, p124] = t; 1285| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1286| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1287| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1288| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1289| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1290| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1291| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124); 1292| | } 1293| | else if constexpr (N == 126) { 1294| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1295| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1296| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1297| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1298| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1299| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1300| | p122, p123, p124, p125] = t; 1301| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1302| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1303| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1304| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1305| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1306| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1307| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125); 1308| | } 1309| | else if constexpr (N == 127) { 1310| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1311| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1312| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1313| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1314| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1315| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1316| | p122, p123, p124, p125, p126] = t; 1317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1319| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1320| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1321| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1322| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1323| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126); 1324| | } 1325| | else if constexpr (N == 128) { 1326| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1327| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1328| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1329| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1330| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1331| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1332| | p122, p123, p124, p125, p126, p127] = t; 1333| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1334| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1335| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1336| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1337| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1338| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1339| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127); 1340| | } 1341| 74.5k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz8fuzz_apiELm13EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 93.8k| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| | else if constexpr (N == 1) { 142| | auto& [p] = t; 143| | return glz::tie(p); 144| | } 145| | else if constexpr (N == 2) { 146| | auto& [p0, p1] = t; 147| | return glz::tie(p0, p1); 148| | } 149| | else if constexpr (N == 3) { 150| | auto& [p0, p1, p2] = t; 151| | return glz::tie(p0, p1, p2); 152| | } 153| | else if constexpr (N == 4) { 154| | auto& [p0, p1, p2, p3] = t; 155| | return glz::tie(p0, p1, p2, p3); 156| | } 157| | else if constexpr (N == 5) { 158| | auto& [p0, p1, p2, p3, p4] = t; 159| | return glz::tie(p0, p1, p2, p3, p4); 160| | } 161| | else if constexpr (N == 6) { 162| | auto& [p0, p1, p2, p3, p4, p5] = t; 163| | return glz::tie(p0, p1, p2, p3, p4, p5); 164| | } 165| | else if constexpr (N == 7) { 166| | auto& [p0, p1, p2, p3, p4, p5, p6] = t; 167| | return glz::tie(p0, p1, p2, p3, p4, p5, p6); 168| | } 169| | else if constexpr (N == 8) { 170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t; 171| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7); 172| | } 173| | else if constexpr (N == 9) { 174| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t; 175| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8); 176| | } 177| | else if constexpr (N == 10) { 178| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t; 179| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 180| | } 181| | else if constexpr (N == 11) { 182| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t; 183| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); 184| | } 185| | else if constexpr (N == 12) { 186| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t; 187| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); 188| | } 189| 93.8k| else if constexpr (N == 13) { 190| 93.8k| auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| 93.8k| return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); 192| | } 193| | else if constexpr (N == 14) { 194| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t; 195| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); 196| | } 197| | else if constexpr (N == 15) { 198| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t; 199| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); 200| | } 201| | else if constexpr (N == 16) { 202| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t; 203| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); 204| | } 205| | else if constexpr (N == 17) { 206| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t; 207| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); 208| | } 209| | else if constexpr (N == 18) { 210| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t; 211| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); 212| | } 213| | else if constexpr (N == 19) { 214| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t; 215| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); 216| | } 217| | else if constexpr (N == 20) { 218| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t; 219| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); 220| | } 221| | else if constexpr (N == 21) { 222| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t; 223| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); 224| | } 225| | else if constexpr (N == 22) { 226| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t; 227| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 228| | p21); 229| | } 230| | else if constexpr (N == 23) { 231| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, 232| | p22] = t; 233| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 234| | p21, p22); 235| | } 236| | else if constexpr (N == 24) { 237| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 238| | p23] = t; 239| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 240| | p21, p22, p23); 241| | } 242| | else if constexpr (N == 25) { 243| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 244| | p23, p24] = t; 245| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 246| | p21, p22, p23, p24); 247| | } 248| | else if constexpr (N == 26) { 249| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 250| | p23, p24, p25] = t; 251| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 252| | p21, p22, p23, p24, p25); 253| | } 254| | else if constexpr (N == 27) { 255| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 256| | p23, p24, p25, p26] = t; 257| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 258| | p21, p22, p23, p24, p25, p26); 259| | } 260| | else if constexpr (N == 28) { 261| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 262| | p23, p24, p25, p26, p27] = t; 263| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 264| | p21, p22, p23, p24, p25, p26, p27); 265| | } 266| | else if constexpr (N == 29) { 267| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 268| | p23, p24, p25, p26, p27, p28] = t; 269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 270| | p21, p22, p23, p24, p25, p26, p27, p28); 271| | } 272| | else if constexpr (N == 30) { 273| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 274| | p23, p24, p25, p26, p27, p28, p29] = t; 275| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 276| | p21, p22, p23, p24, p25, p26, p27, p28, p29); 277| | } 278| | else if constexpr (N == 31) { 279| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 280| | p23, p24, p25, p26, p27, p28, p29, p30] = t; 281| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 282| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30); 283| | } 284| | else if constexpr (N == 32) { 285| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 286| | p23, p24, p25, p26, p27, p28, p29, p30, p31] = t; 287| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 288| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31); 289| | } 290| | else if constexpr (N == 33) { 291| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 292| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t; 293| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 294| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32); 295| | } 296| | else if constexpr (N == 34) { 297| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 298| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t; 299| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 300| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33); 301| | } 302| | else if constexpr (N == 35) { 303| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 304| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t; 305| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 306| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34); 307| | } 308| | else if constexpr (N == 36) { 309| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 310| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t; 311| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 312| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35); 313| | } 314| | else if constexpr (N == 37) { 315| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 316| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t; 317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36); 319| | } 320| | else if constexpr (N == 38) { 321| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 322| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t; 323| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 324| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37); 325| | } 326| | else if constexpr (N == 39) { 327| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 328| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t; 329| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 330| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38); 331| | } 332| | else if constexpr (N == 40) { 333| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 334| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t; 335| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 336| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39); 337| | } 338| | else if constexpr (N == 41) { 339| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 340| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t; 341| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 342| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 343| | p40); 344| | } 345| | else if constexpr (N == 42) { 346| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 347| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t; 348| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 349| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 350| | p40, p41); 351| | } 352| | else if constexpr (N == 43) { 353| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 354| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t; 355| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 356| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 357| | p40, p41, p42); 358| | } 359| | else if constexpr (N == 44) { 360| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 361| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, 362| | p43] = t; 363| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 364| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 365| | p40, p41, p42, p43); 366| | } 367| | else if constexpr (N == 45) { 368| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 369| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 370| | p44] = t; 371| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 372| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 373| | p40, p41, p42, p43, p44); 374| | } 375| | else if constexpr (N == 46) { 376| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 377| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 378| | p44, p45] = t; 379| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 380| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 381| | p40, p41, p42, p43, p44, p45); 382| | } 383| | else if constexpr (N == 47) { 384| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 385| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 386| | p44, p45, p46] = t; 387| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 388| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 389| | p40, p41, p42, p43, p44, p45, p46); 390| | } 391| | else if constexpr (N == 48) { 392| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 393| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 394| | p44, p45, p46, p47] = t; 395| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 396| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 397| | p40, p41, p42, p43, p44, p45, p46, p47); 398| | } 399| | else if constexpr (N == 49) { 400| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 401| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 402| | p44, p45, p46, p47, p48] = t; 403| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 404| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 405| | p40, p41, p42, p43, p44, p45, p46, p47, p48); 406| | } 407| | else if constexpr (N == 50) { 408| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 409| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 410| | p44, p45, p46, p47, p48, p49] = t; 411| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 412| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 413| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49); 414| | } 415| | else if constexpr (N == 51) { 416| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 417| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 418| | p44, p45, p46, p47, p48, p49, p50] = t; 419| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 420| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 421| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50); 422| | } 423| | else if constexpr (N == 52) { 424| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 425| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 426| | p44, p45, p46, p47, p48, p49, p50, p51] = t; 427| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 428| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 429| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51); 430| | } 431| | else if constexpr (N == 53) { 432| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 433| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 434| | p44, p45, p46, p47, p48, p49, p50, p51, p52] = t; 435| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 436| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 437| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52); 438| | } 439| | else if constexpr (N == 54) { 440| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 441| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 442| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t; 443| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 444| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 445| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53); 446| | } 447| | else if constexpr (N == 55) { 448| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 449| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 450| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t; 451| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 452| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 453| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54); 454| | } 455| | else if constexpr (N == 56) { 456| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 457| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 458| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t; 459| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 460| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 461| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55); 462| | } 463| | else if constexpr (N == 57) { 464| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 465| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 466| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t; 467| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 468| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 469| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56); 470| | } 471| | else if constexpr (N == 58) { 472| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 473| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 474| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t; 475| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 476| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 477| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57); 478| | } 479| | else if constexpr (N == 59) { 480| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 481| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 482| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t; 483| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 484| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 485| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58); 486| | } 487| | else if constexpr (N == 60) { 488| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 489| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 490| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t; 491| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 492| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 493| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 494| | p59); 495| | } 496| | else if constexpr (N == 61) { 497| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 498| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 499| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t; 500| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 501| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 502| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 503| | p59, p60); 504| | } 505| | else if constexpr (N == 62) { 506| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 507| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 508| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t; 509| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 510| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 511| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 512| | p59, p60, p61); 513| | } 514| | else if constexpr (N == 63) { 515| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 516| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 517| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t; 518| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 519| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 520| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 521| | p59, p60, p61, p62); 522| | } 523| | else if constexpr (N == 64) { 524| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 525| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 526| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t; 527| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 528| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 529| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 530| | p59, p60, p61, p62, p63); 531| | } 532| | else if constexpr (N == 65) { 533| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 534| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 535| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, 536| | p64] = t; 537| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 538| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 539| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 540| | p59, p60, p61, p62, p63, p64); 541| | } 542| | else if constexpr (N == 66) { 543| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 544| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 545| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 546| | p65] = t; 547| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 548| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 549| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 550| | p59, p60, p61, p62, p63, p64, p65); 551| | } 552| | else if constexpr (N == 67) { 553| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 554| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 555| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 556| | p65, p66] = t; 557| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 558| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 559| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 560| | p59, p60, p61, p62, p63, p64, p65, p66); 561| | } 562| | else if constexpr (N == 68) { 563| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 564| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 565| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 566| | p65, p66, p67] = t; 567| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 568| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 569| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 570| | p59, p60, p61, p62, p63, p64, p65, p66, p67); 571| | } 572| | else if constexpr (N == 69) { 573| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 574| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 575| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 576| | p65, p66, p67, p68] = t; 577| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 578| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 579| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 580| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68); 581| | } 582| | else if constexpr (N == 70) { 583| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 584| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 585| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 586| | p65, p66, p67, p68, p69] = t; 587| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 588| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 589| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 590| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69); 591| | } 592| | else if constexpr (N == 71) { 593| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 594| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 595| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 596| | p65, p66, p67, p68, p69, p70] = t; 597| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 598| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 599| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 600| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70); 601| | } 602| | else if constexpr (N == 72) { 603| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 604| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 605| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 606| | p65, p66, p67, p68, p69, p70, p71] = t; 607| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 608| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 609| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 610| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71); 611| | } 612| | else if constexpr (N == 73) { 613| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 614| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 615| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 616| | p65, p66, p67, p68, p69, p70, p71, p72] = t; 617| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 618| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 619| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 620| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72); 621| | } 622| | else if constexpr (N == 74) { 623| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 624| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 625| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 626| | p65, p66, p67, p68, p69, p70, p71, p72, p73] = t; 627| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 628| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 629| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 630| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73); 631| | } 632| | else if constexpr (N == 75) { 633| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 634| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 635| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 636| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t; 637| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 638| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 639| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 640| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74); 641| | } 642| | else if constexpr (N == 76) { 643| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 644| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 645| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 646| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t; 647| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 648| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 649| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 650| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75); 651| | } 652| | else if constexpr (N == 77) { 653| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 654| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 655| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 656| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t; 657| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 658| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 659| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 660| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76); 661| | } 662| | else if constexpr (N == 78) { 663| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 664| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 665| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 666| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t; 667| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 668| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 669| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 670| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77); 671| | } 672| | else if constexpr (N == 79) { 673| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 674| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 675| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 676| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t; 677| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 678| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 679| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 680| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 681| | p78); 682| | } 683| | else if constexpr (N == 80) { 684| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 685| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 686| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 687| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t; 688| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 689| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 690| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 691| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 692| | p78, p79); 693| | } 694| | else if constexpr (N == 81) { 695| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 696| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 697| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 698| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t; 699| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 700| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 701| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 702| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 703| | p78, p79, p80); 704| | } 705| | else if constexpr (N == 82) { 706| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 707| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 708| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 709| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t; 710| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 711| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 712| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 713| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 714| | p78, p79, p80, p81); 715| | } 716| | else if constexpr (N == 83) { 717| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 718| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 719| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 720| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t; 721| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 722| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 723| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 724| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 725| | p78, p79, p80, p81, p82); 726| | } 727| | else if constexpr (N == 84) { 728| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 729| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 730| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 731| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t; 732| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 733| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 734| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 735| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 736| | p78, p79, p80, p81, p82, p83); 737| | } 738| | else if constexpr (N == 85) { 739| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 740| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 741| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 742| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t; 743| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 744| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 745| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 746| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 747| | p78, p79, p80, p81, p82, p83, p84); 748| | } 749| | else if constexpr (N == 86) { 750| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 751| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 752| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 753| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, 754| | p85] = t; 755| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 756| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 757| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 758| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 759| | p78, p79, p80, p81, p82, p83, p84, p85); 760| | } 761| | else if constexpr (N == 87) { 762| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 763| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 764| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 765| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 766| | p86] = t; 767| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 768| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 769| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 770| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 771| | p78, p79, p80, p81, p82, p83, p84, p85, p86); 772| | } 773| | else if constexpr (N == 88) { 774| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 775| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 776| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 777| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 778| | p86, p87] = t; 779| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 780| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 781| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 782| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 783| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87); 784| | } 785| | else if constexpr (N == 89) { 786| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 787| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 788| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 789| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 790| | p86, p87, p88] = t; 791| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 792| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 793| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 794| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 795| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88); 796| | } 797| | else if constexpr (N == 90) { 798| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 799| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 800| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 801| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 802| | p86, p87, p88, p89] = t; 803| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 804| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 805| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 806| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 807| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89); 808| | } 809| | else if constexpr (N == 91) { 810| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 811| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 812| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 813| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 814| | p86, p87, p88, p89, p90] = t; 815| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 816| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 817| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 818| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 819| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90); 820| | } 821| | else if constexpr (N == 92) { 822| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 823| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 824| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 825| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 826| | p86, p87, p88, p89, p90, p91] = t; 827| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 828| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 829| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 830| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 831| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91); 832| | } 833| | else if constexpr (N == 93) { 834| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 835| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 836| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 837| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 838| | p86, p87, p88, p89, p90, p91, p92] = t; 839| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 840| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 841| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 842| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 843| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92); 844| | } 845| | else if constexpr (N == 94) { 846| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 847| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 848| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 849| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 850| | p86, p87, p88, p89, p90, p91, p92, p93] = t; 851| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 852| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 853| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 854| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 855| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93); 856| | } 857| | else if constexpr (N == 95) { 858| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 859| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 860| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 861| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 862| | p86, p87, p88, p89, p90, p91, p92, p93, p94] = t; 863| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 864| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 865| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 866| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 867| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94); 868| | } 869| | else if constexpr (N == 96) { 870| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 871| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 872| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 873| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 874| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t; 875| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 876| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 877| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 878| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 879| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95); 880| | } 881| | else if constexpr (N == 97) { 882| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 883| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 884| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 885| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 886| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t; 887| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 888| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 889| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 890| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 891| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96); 892| | } 893| | else if constexpr (N == 98) { 894| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 895| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 896| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 897| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 898| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t; 899| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 900| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 901| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 902| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 903| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 904| | p97); 905| | } 906| | else if constexpr (N == 99) { 907| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 908| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 909| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 910| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 911| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t; 912| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 913| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 914| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 915| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 916| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 917| | p97, p98); 918| | } 919| | else if constexpr (N == 100) { 920| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 921| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 922| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 923| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 924| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t; 925| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 926| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 927| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 928| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 929| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 930| | p97, p98, p99); 931| | } 932| | else if constexpr (N == 101) { 933| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 934| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 935| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 936| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 937| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t; 938| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 939| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 940| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 941| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 942| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 943| | p97, p98, p99, p100); 944| | } 945| | else if constexpr (N == 102) { 946| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 947| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 948| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 949| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 950| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t; 951| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 952| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 953| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 954| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 955| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 956| | p97, p98, p99, p100, p101); 957| | } 958| | else if constexpr (N == 103) { 959| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 960| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 961| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 962| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 963| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t; 964| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 965| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 966| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 967| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 968| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 969| | p97, p98, p99, p100, p101, p102); 970| | } 971| | else if constexpr (N == 104) { 972| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 973| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 974| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 975| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 976| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t; 977| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 978| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 979| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 980| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 981| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 982| | p97, p98, p99, p100, p101, p102, p103); 983| | } 984| | else if constexpr (N == 105) { 985| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 986| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 987| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 988| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 989| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t; 990| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 991| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 992| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 993| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 994| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 995| | p97, p98, p99, p100, p101, p102, p103, p104); 996| | } 997| | else if constexpr (N == 106) { 998| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 999| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1000| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1001| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1002| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1003| | p105] = t; 1004| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1005| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1006| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1007| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1008| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1009| | p97, p98, p99, p100, p101, p102, p103, p104, p105); 1010| | } 1011| | else if constexpr (N == 107) { 1012| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1013| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1014| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1015| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1016| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1017| | p105, p106] = t; 1018| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1019| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1020| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1021| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1022| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1023| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106); 1024| | } 1025| | else if constexpr (N == 108) { 1026| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1027| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1028| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1029| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1030| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1031| | p105, p106, p107] = t; 1032| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1033| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1034| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1035| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1036| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1037| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107); 1038| | } 1039| | else if constexpr (N == 109) { 1040| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1041| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1042| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1043| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1044| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1045| | p105, p106, p107, p108] = t; 1046| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1047| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1048| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1049| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1050| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1051| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108); 1052| | } 1053| | else if constexpr (N == 110) { 1054| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1055| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1056| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1057| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1058| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1059| | p105, p106, p107, p108, p109] = t; 1060| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1061| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1062| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1063| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1064| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1065| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109); 1066| | } 1067| | else if constexpr (N == 111) { 1068| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1069| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1070| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1071| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1072| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1073| | p105, p106, p107, p108, p109, p110] = t; 1074| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1075| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1076| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1077| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1078| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1079| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110); 1080| | } 1081| | else if constexpr (N == 112) { 1082| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1083| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1084| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1085| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1086| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1087| | p105, p106, p107, p108, p109, p110, p111] = t; 1088| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1089| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1090| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1091| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1092| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1093| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111); 1094| | } 1095| | else if constexpr (N == 113) { 1096| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1097| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1098| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1099| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1100| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1101| | p105, p106, p107, p108, p109, p110, p111, p112] = t; 1102| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1103| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1104| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1105| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1106| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1107| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112); 1108| | } 1109| | else if constexpr (N == 114) { 1110| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1111| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1112| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1113| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1114| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1115| | p105, p106, p107, p108, p109, p110, p111, p112, p113] = t; 1116| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1117| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1118| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1119| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1120| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1121| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1122| | p113); 1123| | } 1124| | else if constexpr (N == 115) { 1125| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1126| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1127| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1128| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1129| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1130| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t; 1131| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1132| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1133| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1134| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1135| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1136| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1137| | p113, p114); 1138| | } 1139| | else if constexpr (N == 116) { 1140| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1141| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1142| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1143| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1144| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1145| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t; 1146| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1147| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1148| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1149| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1150| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1151| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1152| | p113, p114, p115); 1153| | } 1154| | else if constexpr (N == 117) { 1155| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1156| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1157| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1158| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1159| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1160| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t; 1161| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1162| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1163| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1164| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1165| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1166| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1167| | p113, p114, p115, p116); 1168| | } 1169| | else if constexpr (N == 118) { 1170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1171| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1172| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1173| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1174| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1175| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t; 1176| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1177| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1178| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1179| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1180| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1181| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1182| | p113, p114, p115, p116, p117); 1183| | } 1184| | else if constexpr (N == 119) { 1185| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1186| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1187| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1188| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1189| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1190| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t; 1191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1192| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1193| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1194| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1195| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1196| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1197| | p113, p114, p115, p116, p117, p118); 1198| | } 1199| | else if constexpr (N == 120) { 1200| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1201| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1202| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1203| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1204| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1205| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t; 1206| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1207| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1208| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1209| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1210| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1211| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1212| | p113, p114, p115, p116, p117, p118, p119); 1213| | } 1214| | else if constexpr (N == 121) { 1215| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1216| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1217| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1218| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1219| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1220| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t; 1221| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1222| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1223| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1224| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1225| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1226| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1227| | p113, p114, p115, p116, p117, p118, p119, p120); 1228| | } 1229| | else if constexpr (N == 122) { 1230| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1231| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1232| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1233| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1234| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1235| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] = 1236| | t; 1237| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1238| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1239| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1240| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1241| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1242| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1243| | p113, p114, p115, p116, p117, p118, p119, p120, p121); 1244| | } 1245| | else if constexpr (N == 123) { 1246| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1247| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1248| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1249| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1250| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1251| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1252| | p122] = t; 1253| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1254| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1255| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1256| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1257| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1258| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1259| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122); 1260| | } 1261| | else if constexpr (N == 124) { 1262| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1263| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1264| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1265| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1266| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1267| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1268| | p122, p123] = t; 1269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1270| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1271| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1272| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1273| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1274| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1275| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123); 1276| | } 1277| | else if constexpr (N == 125) { 1278| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1279| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1280| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1281| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1282| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1283| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1284| | p122, p123, p124] = t; 1285| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1286| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1287| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1288| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1289| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1290| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1291| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124); 1292| | } 1293| | else if constexpr (N == 126) { 1294| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1295| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1296| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1297| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1298| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1299| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1300| | p122, p123, p124, p125] = t; 1301| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1302| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1303| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1304| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1305| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1306| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1307| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125); 1308| | } 1309| | else if constexpr (N == 127) { 1310| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1311| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1312| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1313| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1314| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1315| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1316| | p122, p123, p124, p125, p126] = t; 1317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1319| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1320| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1321| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1322| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1323| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126); 1324| | } 1325| | else if constexpr (N == 128) { 1326| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1327| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1328| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1329| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1330| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1331| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1332| | p122, p123, p124, p125, p126, p127] = t; 1333| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1334| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1335| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1336| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1337| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1338| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1339| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127); 1340| | } 1341| 93.8k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz6nestedELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 80.4k| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| | else if constexpr (N == 1) { 142| | auto& [p] = t; 143| | return glz::tie(p); 144| | } 145| 80.4k| else if constexpr (N == 2) { 146| 80.4k| auto& [p0, p1] = t; 147| 80.4k| return glz::tie(p0, p1); 148| | } 149| | else if constexpr (N == 3) { 150| | auto& [p0, p1, p2] = t; 151| | return glz::tie(p0, p1, p2); 152| | } 153| | else if constexpr (N == 4) { 154| | auto& [p0, p1, p2, p3] = t; 155| | return glz::tie(p0, p1, p2, p3); 156| | } 157| | else if constexpr (N == 5) { 158| | auto& [p0, p1, p2, p3, p4] = t; 159| | return glz::tie(p0, p1, p2, p3, p4); 160| | } 161| | else if constexpr (N == 6) { 162| | auto& [p0, p1, p2, p3, p4, p5] = t; 163| | return glz::tie(p0, p1, p2, p3, p4, p5); 164| | } 165| | else if constexpr (N == 7) { 166| | auto& [p0, p1, p2, p3, p4, p5, p6] = t; 167| | return glz::tie(p0, p1, p2, p3, p4, p5, p6); 168| | } 169| | else if constexpr (N == 8) { 170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t; 171| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7); 172| | } 173| | else if constexpr (N == 9) { 174| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t; 175| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8); 176| | } 177| | else if constexpr (N == 10) { 178| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t; 179| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 180| | } 181| | else if constexpr (N == 11) { 182| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t; 183| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); 184| | } 185| | else if constexpr (N == 12) { 186| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t; 187| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); 188| | } 189| | else if constexpr (N == 13) { 190| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); 192| | } 193| | else if constexpr (N == 14) { 194| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t; 195| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); 196| | } 197| | else if constexpr (N == 15) { 198| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t; 199| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); 200| | } 201| | else if constexpr (N == 16) { 202| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t; 203| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); 204| | } 205| | else if constexpr (N == 17) { 206| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t; 207| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); 208| | } 209| | else if constexpr (N == 18) { 210| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t; 211| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); 212| | } 213| | else if constexpr (N == 19) { 214| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t; 215| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); 216| | } 217| | else if constexpr (N == 20) { 218| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t; 219| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); 220| | } 221| | else if constexpr (N == 21) { 222| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t; 223| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); 224| | } 225| | else if constexpr (N == 22) { 226| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t; 227| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 228| | p21); 229| | } 230| | else if constexpr (N == 23) { 231| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, 232| | p22] = t; 233| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 234| | p21, p22); 235| | } 236| | else if constexpr (N == 24) { 237| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 238| | p23] = t; 239| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 240| | p21, p22, p23); 241| | } 242| | else if constexpr (N == 25) { 243| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 244| | p23, p24] = t; 245| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 246| | p21, p22, p23, p24); 247| | } 248| | else if constexpr (N == 26) { 249| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 250| | p23, p24, p25] = t; 251| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 252| | p21, p22, p23, p24, p25); 253| | } 254| | else if constexpr (N == 27) { 255| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 256| | p23, p24, p25, p26] = t; 257| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 258| | p21, p22, p23, p24, p25, p26); 259| | } 260| | else if constexpr (N == 28) { 261| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 262| | p23, p24, p25, p26, p27] = t; 263| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 264| | p21, p22, p23, p24, p25, p26, p27); 265| | } 266| | else if constexpr (N == 29) { 267| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 268| | p23, p24, p25, p26, p27, p28] = t; 269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 270| | p21, p22, p23, p24, p25, p26, p27, p28); 271| | } 272| | else if constexpr (N == 30) { 273| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 274| | p23, p24, p25, p26, p27, p28, p29] = t; 275| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 276| | p21, p22, p23, p24, p25, p26, p27, p28, p29); 277| | } 278| | else if constexpr (N == 31) { 279| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 280| | p23, p24, p25, p26, p27, p28, p29, p30] = t; 281| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 282| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30); 283| | } 284| | else if constexpr (N == 32) { 285| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 286| | p23, p24, p25, p26, p27, p28, p29, p30, p31] = t; 287| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 288| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31); 289| | } 290| | else if constexpr (N == 33) { 291| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 292| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t; 293| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 294| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32); 295| | } 296| | else if constexpr (N == 34) { 297| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 298| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t; 299| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 300| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33); 301| | } 302| | else if constexpr (N == 35) { 303| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 304| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t; 305| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 306| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34); 307| | } 308| | else if constexpr (N == 36) { 309| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 310| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t; 311| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 312| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35); 313| | } 314| | else if constexpr (N == 37) { 315| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 316| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t; 317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36); 319| | } 320| | else if constexpr (N == 38) { 321| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 322| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t; 323| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 324| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37); 325| | } 326| | else if constexpr (N == 39) { 327| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 328| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t; 329| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 330| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38); 331| | } 332| | else if constexpr (N == 40) { 333| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 334| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t; 335| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 336| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39); 337| | } 338| | else if constexpr (N == 41) { 339| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 340| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t; 341| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 342| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 343| | p40); 344| | } 345| | else if constexpr (N == 42) { 346| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 347| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t; 348| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 349| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 350| | p40, p41); 351| | } 352| | else if constexpr (N == 43) { 353| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 354| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t; 355| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 356| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 357| | p40, p41, p42); 358| | } 359| | else if constexpr (N == 44) { 360| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 361| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, 362| | p43] = t; 363| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 364| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 365| | p40, p41, p42, p43); 366| | } 367| | else if constexpr (N == 45) { 368| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 369| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 370| | p44] = t; 371| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 372| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 373| | p40, p41, p42, p43, p44); 374| | } 375| | else if constexpr (N == 46) { 376| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 377| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 378| | p44, p45] = t; 379| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 380| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 381| | p40, p41, p42, p43, p44, p45); 382| | } 383| | else if constexpr (N == 47) { 384| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 385| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 386| | p44, p45, p46] = t; 387| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 388| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 389| | p40, p41, p42, p43, p44, p45, p46); 390| | } 391| | else if constexpr (N == 48) { 392| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 393| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 394| | p44, p45, p46, p47] = t; 395| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 396| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 397| | p40, p41, p42, p43, p44, p45, p46, p47); 398| | } 399| | else if constexpr (N == 49) { 400| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 401| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 402| | p44, p45, p46, p47, p48] = t; 403| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 404| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 405| | p40, p41, p42, p43, p44, p45, p46, p47, p48); 406| | } 407| | else if constexpr (N == 50) { 408| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 409| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 410| | p44, p45, p46, p47, p48, p49] = t; 411| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 412| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 413| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49); 414| | } 415| | else if constexpr (N == 51) { 416| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 417| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 418| | p44, p45, p46, p47, p48, p49, p50] = t; 419| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 420| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 421| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50); 422| | } 423| | else if constexpr (N == 52) { 424| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 425| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 426| | p44, p45, p46, p47, p48, p49, p50, p51] = t; 427| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 428| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 429| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51); 430| | } 431| | else if constexpr (N == 53) { 432| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 433| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 434| | p44, p45, p46, p47, p48, p49, p50, p51, p52] = t; 435| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 436| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 437| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52); 438| | } 439| | else if constexpr (N == 54) { 440| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 441| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 442| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t; 443| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 444| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 445| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53); 446| | } 447| | else if constexpr (N == 55) { 448| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 449| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 450| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t; 451| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 452| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 453| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54); 454| | } 455| | else if constexpr (N == 56) { 456| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 457| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 458| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t; 459| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 460| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 461| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55); 462| | } 463| | else if constexpr (N == 57) { 464| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 465| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 466| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t; 467| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 468| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 469| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56); 470| | } 471| | else if constexpr (N == 58) { 472| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 473| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 474| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t; 475| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 476| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 477| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57); 478| | } 479| | else if constexpr (N == 59) { 480| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 481| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 482| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t; 483| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 484| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 485| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58); 486| | } 487| | else if constexpr (N == 60) { 488| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 489| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 490| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t; 491| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 492| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 493| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 494| | p59); 495| | } 496| | else if constexpr (N == 61) { 497| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 498| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 499| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t; 500| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 501| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 502| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 503| | p59, p60); 504| | } 505| | else if constexpr (N == 62) { 506| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 507| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 508| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t; 509| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 510| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 511| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 512| | p59, p60, p61); 513| | } 514| | else if constexpr (N == 63) { 515| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 516| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 517| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t; 518| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 519| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 520| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 521| | p59, p60, p61, p62); 522| | } 523| | else if constexpr (N == 64) { 524| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 525| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 526| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t; 527| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 528| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 529| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 530| | p59, p60, p61, p62, p63); 531| | } 532| | else if constexpr (N == 65) { 533| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 534| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 535| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, 536| | p64] = t; 537| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 538| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 539| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 540| | p59, p60, p61, p62, p63, p64); 541| | } 542| | else if constexpr (N == 66) { 543| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 544| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 545| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 546| | p65] = t; 547| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 548| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 549| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 550| | p59, p60, p61, p62, p63, p64, p65); 551| | } 552| | else if constexpr (N == 67) { 553| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 554| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 555| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 556| | p65, p66] = t; 557| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 558| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 559| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 560| | p59, p60, p61, p62, p63, p64, p65, p66); 561| | } 562| | else if constexpr (N == 68) { 563| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 564| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 565| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 566| | p65, p66, p67] = t; 567| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 568| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 569| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 570| | p59, p60, p61, p62, p63, p64, p65, p66, p67); 571| | } 572| | else if constexpr (N == 69) { 573| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 574| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 575| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 576| | p65, p66, p67, p68] = t; 577| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 578| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 579| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 580| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68); 581| | } 582| | else if constexpr (N == 70) { 583| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 584| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 585| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 586| | p65, p66, p67, p68, p69] = t; 587| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 588| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 589| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 590| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69); 591| | } 592| | else if constexpr (N == 71) { 593| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 594| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 595| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 596| | p65, p66, p67, p68, p69, p70] = t; 597| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 598| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 599| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 600| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70); 601| | } 602| | else if constexpr (N == 72) { 603| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 604| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 605| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 606| | p65, p66, p67, p68, p69, p70, p71] = t; 607| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 608| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 609| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 610| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71); 611| | } 612| | else if constexpr (N == 73) { 613| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 614| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 615| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 616| | p65, p66, p67, p68, p69, p70, p71, p72] = t; 617| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 618| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 619| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 620| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72); 621| | } 622| | else if constexpr (N == 74) { 623| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 624| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 625| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 626| | p65, p66, p67, p68, p69, p70, p71, p72, p73] = t; 627| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 628| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 629| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 630| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73); 631| | } 632| | else if constexpr (N == 75) { 633| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 634| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 635| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 636| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t; 637| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 638| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 639| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 640| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74); 641| | } 642| | else if constexpr (N == 76) { 643| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 644| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 645| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 646| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t; 647| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 648| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 649| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 650| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75); 651| | } 652| | else if constexpr (N == 77) { 653| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 654| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 655| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 656| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t; 657| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 658| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 659| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 660| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76); 661| | } 662| | else if constexpr (N == 78) { 663| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 664| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 665| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 666| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t; 667| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 668| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 669| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 670| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77); 671| | } 672| | else if constexpr (N == 79) { 673| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 674| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 675| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 676| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t; 677| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 678| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 679| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 680| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 681| | p78); 682| | } 683| | else if constexpr (N == 80) { 684| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 685| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 686| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 687| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t; 688| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 689| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 690| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 691| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 692| | p78, p79); 693| | } 694| | else if constexpr (N == 81) { 695| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 696| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 697| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 698| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t; 699| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 700| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 701| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 702| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 703| | p78, p79, p80); 704| | } 705| | else if constexpr (N == 82) { 706| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 707| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 708| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 709| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t; 710| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 711| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 712| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 713| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 714| | p78, p79, p80, p81); 715| | } 716| | else if constexpr (N == 83) { 717| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 718| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 719| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 720| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t; 721| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 722| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 723| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 724| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 725| | p78, p79, p80, p81, p82); 726| | } 727| | else if constexpr (N == 84) { 728| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 729| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 730| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 731| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t; 732| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 733| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 734| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 735| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 736| | p78, p79, p80, p81, p82, p83); 737| | } 738| | else if constexpr (N == 85) { 739| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 740| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 741| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 742| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t; 743| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 744| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 745| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 746| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 747| | p78, p79, p80, p81, p82, p83, p84); 748| | } 749| | else if constexpr (N == 86) { 750| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 751| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 752| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 753| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, 754| | p85] = t; 755| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 756| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 757| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 758| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 759| | p78, p79, p80, p81, p82, p83, p84, p85); 760| | } 761| | else if constexpr (N == 87) { 762| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 763| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 764| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 765| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 766| | p86] = t; 767| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 768| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 769| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 770| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 771| | p78, p79, p80, p81, p82, p83, p84, p85, p86); 772| | } 773| | else if constexpr (N == 88) { 774| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 775| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 776| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 777| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 778| | p86, p87] = t; 779| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 780| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 781| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 782| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 783| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87); 784| | } 785| | else if constexpr (N == 89) { 786| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 787| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 788| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 789| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 790| | p86, p87, p88] = t; 791| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 792| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 793| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 794| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 795| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88); 796| | } 797| | else if constexpr (N == 90) { 798| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 799| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 800| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 801| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 802| | p86, p87, p88, p89] = t; 803| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 804| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 805| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 806| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 807| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89); 808| | } 809| | else if constexpr (N == 91) { 810| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 811| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 812| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 813| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 814| | p86, p87, p88, p89, p90] = t; 815| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 816| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 817| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 818| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 819| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90); 820| | } 821| | else if constexpr (N == 92) { 822| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 823| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 824| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 825| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 826| | p86, p87, p88, p89, p90, p91] = t; 827| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 828| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 829| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 830| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 831| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91); 832| | } 833| | else if constexpr (N == 93) { 834| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 835| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 836| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 837| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 838| | p86, p87, p88, p89, p90, p91, p92] = t; 839| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 840| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 841| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 842| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 843| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92); 844| | } 845| | else if constexpr (N == 94) { 846| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 847| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 848| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 849| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 850| | p86, p87, p88, p89, p90, p91, p92, p93] = t; 851| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 852| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 853| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 854| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 855| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93); 856| | } 857| | else if constexpr (N == 95) { 858| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 859| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 860| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 861| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 862| | p86, p87, p88, p89, p90, p91, p92, p93, p94] = t; 863| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 864| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 865| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 866| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 867| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94); 868| | } 869| | else if constexpr (N == 96) { 870| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 871| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 872| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 873| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 874| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t; 875| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 876| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 877| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 878| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 879| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95); 880| | } 881| | else if constexpr (N == 97) { 882| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 883| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 884| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 885| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 886| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t; 887| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 888| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 889| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 890| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 891| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96); 892| | } 893| | else if constexpr (N == 98) { 894| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 895| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 896| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 897| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 898| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t; 899| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 900| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 901| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 902| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 903| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 904| | p97); 905| | } 906| | else if constexpr (N == 99) { 907| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 908| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 909| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 910| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 911| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t; 912| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 913| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 914| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 915| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 916| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 917| | p97, p98); 918| | } 919| | else if constexpr (N == 100) { 920| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 921| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 922| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 923| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 924| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t; 925| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 926| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 927| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 928| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 929| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 930| | p97, p98, p99); 931| | } 932| | else if constexpr (N == 101) { 933| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 934| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 935| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 936| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 937| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t; 938| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 939| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 940| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 941| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 942| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 943| | p97, p98, p99, p100); 944| | } 945| | else if constexpr (N == 102) { 946| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 947| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 948| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 949| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 950| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t; 951| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 952| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 953| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 954| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 955| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 956| | p97, p98, p99, p100, p101); 957| | } 958| | else if constexpr (N == 103) { 959| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 960| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 961| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 962| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 963| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t; 964| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 965| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 966| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 967| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 968| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 969| | p97, p98, p99, p100, p101, p102); 970| | } 971| | else if constexpr (N == 104) { 972| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 973| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 974| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 975| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 976| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t; 977| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 978| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 979| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 980| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 981| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 982| | p97, p98, p99, p100, p101, p102, p103); 983| | } 984| | else if constexpr (N == 105) { 985| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 986| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 987| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 988| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 989| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t; 990| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 991| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 992| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 993| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 994| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 995| | p97, p98, p99, p100, p101, p102, p103, p104); 996| | } 997| | else if constexpr (N == 106) { 998| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 999| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1000| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1001| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1002| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1003| | p105] = t; 1004| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1005| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1006| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1007| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1008| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1009| | p97, p98, p99, p100, p101, p102, p103, p104, p105); 1010| | } 1011| | else if constexpr (N == 107) { 1012| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1013| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1014| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1015| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1016| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1017| | p105, p106] = t; 1018| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1019| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1020| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1021| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1022| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1023| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106); 1024| | } 1025| | else if constexpr (N == 108) { 1026| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1027| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1028| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1029| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1030| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1031| | p105, p106, p107] = t; 1032| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1033| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1034| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1035| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1036| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1037| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107); 1038| | } 1039| | else if constexpr (N == 109) { 1040| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1041| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1042| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1043| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1044| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1045| | p105, p106, p107, p108] = t; 1046| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1047| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1048| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1049| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1050| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1051| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108); 1052| | } 1053| | else if constexpr (N == 110) { 1054| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1055| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1056| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1057| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1058| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1059| | p105, p106, p107, p108, p109] = t; 1060| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1061| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1062| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1063| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1064| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1065| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109); 1066| | } 1067| | else if constexpr (N == 111) { 1068| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1069| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1070| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1071| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1072| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1073| | p105, p106, p107, p108, p109, p110] = t; 1074| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1075| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1076| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1077| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1078| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1079| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110); 1080| | } 1081| | else if constexpr (N == 112) { 1082| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1083| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1084| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1085| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1086| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1087| | p105, p106, p107, p108, p109, p110, p111] = t; 1088| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1089| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1090| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1091| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1092| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1093| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111); 1094| | } 1095| | else if constexpr (N == 113) { 1096| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1097| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1098| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1099| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1100| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1101| | p105, p106, p107, p108, p109, p110, p111, p112] = t; 1102| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1103| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1104| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1105| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1106| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1107| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112); 1108| | } 1109| | else if constexpr (N == 114) { 1110| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1111| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1112| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1113| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1114| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1115| | p105, p106, p107, p108, p109, p110, p111, p112, p113] = t; 1116| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1117| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1118| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1119| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1120| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1121| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1122| | p113); 1123| | } 1124| | else if constexpr (N == 115) { 1125| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1126| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1127| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1128| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1129| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1130| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t; 1131| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1132| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1133| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1134| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1135| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1136| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1137| | p113, p114); 1138| | } 1139| | else if constexpr (N == 116) { 1140| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1141| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1142| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1143| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1144| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1145| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t; 1146| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1147| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1148| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1149| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1150| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1151| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1152| | p113, p114, p115); 1153| | } 1154| | else if constexpr (N == 117) { 1155| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1156| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1157| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1158| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1159| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1160| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t; 1161| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1162| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1163| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1164| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1165| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1166| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1167| | p113, p114, p115, p116); 1168| | } 1169| | else if constexpr (N == 118) { 1170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1171| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1172| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1173| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1174| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1175| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t; 1176| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1177| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1178| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1179| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1180| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1181| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1182| | p113, p114, p115, p116, p117); 1183| | } 1184| | else if constexpr (N == 119) { 1185| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1186| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1187| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1188| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1189| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1190| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t; 1191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1192| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1193| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1194| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1195| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1196| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1197| | p113, p114, p115, p116, p117, p118); 1198| | } 1199| | else if constexpr (N == 120) { 1200| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1201| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1202| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1203| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1204| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1205| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t; 1206| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1207| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1208| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1209| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1210| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1211| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1212| | p113, p114, p115, p116, p117, p118, p119); 1213| | } 1214| | else if constexpr (N == 121) { 1215| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1216| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1217| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1218| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1219| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1220| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t; 1221| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1222| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1223| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1224| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1225| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1226| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1227| | p113, p114, p115, p116, p117, p118, p119, p120); 1228| | } 1229| | else if constexpr (N == 122) { 1230| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1231| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1232| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1233| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1234| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1235| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] = 1236| | t; 1237| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1238| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1239| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1240| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1241| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1242| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1243| | p113, p114, p115, p116, p117, p118, p119, p120, p121); 1244| | } 1245| | else if constexpr (N == 123) { 1246| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1247| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1248| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1249| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1250| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1251| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1252| | p122] = t; 1253| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1254| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1255| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1256| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1257| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1258| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1259| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122); 1260| | } 1261| | else if constexpr (N == 124) { 1262| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1263| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1264| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1265| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1266| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1267| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1268| | p122, p123] = t; 1269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1270| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1271| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1272| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1273| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1274| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1275| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123); 1276| | } 1277| | else if constexpr (N == 125) { 1278| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1279| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1280| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1281| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1282| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1283| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1284| | p122, p123, p124] = t; 1285| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1286| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1287| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1288| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1289| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1290| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1291| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124); 1292| | } 1293| | else if constexpr (N == 126) { 1294| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1295| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1296| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1297| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1298| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1299| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1300| | p122, p123, p124, p125] = t; 1301| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1302| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1303| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1304| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1305| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1306| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1307| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125); 1308| | } 1309| | else if constexpr (N == 127) { 1310| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1311| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1312| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1313| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1314| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1315| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1316| | p122, p123, p124, p125, p126] = t; 1317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1319| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1320| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1321| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1322| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1323| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126); 1324| | } 1325| | else if constexpr (N == 128) { 1326| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1327| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1328| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1329| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1330| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1331| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1332| | p122, p123, p124, p125, p126, p127] = t; 1333| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1334| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1335| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1336| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1337| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1338| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1339| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127); 1340| | } 1341| 80.4k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz6amountELm1EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 315| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| 315| else if constexpr (N == 1) { 142| 315| auto& [p] = t; 143| 315| return glz::tie(p); 144| | } 145| | else if constexpr (N == 2) { 146| | auto& [p0, p1] = t; 147| | return glz::tie(p0, p1); 148| | } 149| | else if constexpr (N == 3) { 150| | auto& [p0, p1, p2] = t; 151| | return glz::tie(p0, p1, p2); 152| | } 153| | else if constexpr (N == 4) { 154| | auto& [p0, p1, p2, p3] = t; 155| | return glz::tie(p0, p1, p2, p3); 156| | } 157| | else if constexpr (N == 5) { 158| | auto& [p0, p1, p2, p3, p4] = t; 159| | return glz::tie(p0, p1, p2, p3, p4); 160| | } 161| | else if constexpr (N == 6) { 162| | auto& [p0, p1, p2, p3, p4, p5] = t; 163| | return glz::tie(p0, p1, p2, p3, p4, p5); 164| | } 165| | else if constexpr (N == 7) { 166| | auto& [p0, p1, p2, p3, p4, p5, p6] = t; 167| | return glz::tie(p0, p1, p2, p3, p4, p5, p6); 168| | } 169| | else if constexpr (N == 8) { 170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7] = t; 171| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7); 172| | } 173| | else if constexpr (N == 9) { 174| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8] = t; 175| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8); 176| | } 177| | else if constexpr (N == 10) { 178| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9] = t; 179| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); 180| | } 181| | else if constexpr (N == 11) { 182| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10] = t; 183| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); 184| | } 185| | else if constexpr (N == 12) { 186| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11] = t; 187| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); 188| | } 189| | else if constexpr (N == 13) { 190| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); 192| | } 193| | else if constexpr (N == 14) { 194| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13] = t; 195| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); 196| | } 197| | else if constexpr (N == 15) { 198| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14] = t; 199| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); 200| | } 201| | else if constexpr (N == 16) { 202| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15] = t; 203| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15); 204| | } 205| | else if constexpr (N == 17) { 206| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16] = t; 207| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); 208| | } 209| | else if constexpr (N == 18) { 210| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17] = t; 211| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17); 212| | } 213| | else if constexpr (N == 19) { 214| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18] = t; 215| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18); 216| | } 217| | else if constexpr (N == 20) { 218| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19] = t; 219| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19); 220| | } 221| | else if constexpr (N == 21) { 222| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20] = t; 223| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20); 224| | } 225| | else if constexpr (N == 22) { 226| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21] = t; 227| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 228| | p21); 229| | } 230| | else if constexpr (N == 23) { 231| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, 232| | p22] = t; 233| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 234| | p21, p22); 235| | } 236| | else if constexpr (N == 24) { 237| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 238| | p23] = t; 239| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 240| | p21, p22, p23); 241| | } 242| | else if constexpr (N == 25) { 243| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 244| | p23, p24] = t; 245| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 246| | p21, p22, p23, p24); 247| | } 248| | else if constexpr (N == 26) { 249| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 250| | p23, p24, p25] = t; 251| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 252| | p21, p22, p23, p24, p25); 253| | } 254| | else if constexpr (N == 27) { 255| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 256| | p23, p24, p25, p26] = t; 257| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 258| | p21, p22, p23, p24, p25, p26); 259| | } 260| | else if constexpr (N == 28) { 261| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 262| | p23, p24, p25, p26, p27] = t; 263| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 264| | p21, p22, p23, p24, p25, p26, p27); 265| | } 266| | else if constexpr (N == 29) { 267| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 268| | p23, p24, p25, p26, p27, p28] = t; 269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 270| | p21, p22, p23, p24, p25, p26, p27, p28); 271| | } 272| | else if constexpr (N == 30) { 273| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 274| | p23, p24, p25, p26, p27, p28, p29] = t; 275| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 276| | p21, p22, p23, p24, p25, p26, p27, p28, p29); 277| | } 278| | else if constexpr (N == 31) { 279| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 280| | p23, p24, p25, p26, p27, p28, p29, p30] = t; 281| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 282| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30); 283| | } 284| | else if constexpr (N == 32) { 285| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 286| | p23, p24, p25, p26, p27, p28, p29, p30, p31] = t; 287| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 288| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31); 289| | } 290| | else if constexpr (N == 33) { 291| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 292| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32] = t; 293| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 294| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32); 295| | } 296| | else if constexpr (N == 34) { 297| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 298| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33] = t; 299| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 300| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33); 301| | } 302| | else if constexpr (N == 35) { 303| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 304| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34] = t; 305| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 306| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34); 307| | } 308| | else if constexpr (N == 36) { 309| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 310| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35] = t; 311| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 312| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35); 313| | } 314| | else if constexpr (N == 37) { 315| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 316| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36] = t; 317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36); 319| | } 320| | else if constexpr (N == 38) { 321| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 322| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37] = t; 323| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 324| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37); 325| | } 326| | else if constexpr (N == 39) { 327| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 328| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38] = t; 329| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 330| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38); 331| | } 332| | else if constexpr (N == 40) { 333| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 334| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39] = t; 335| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 336| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39); 337| | } 338| | else if constexpr (N == 41) { 339| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 340| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40] = t; 341| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 342| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 343| | p40); 344| | } 345| | else if constexpr (N == 42) { 346| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 347| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41] = t; 348| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 349| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 350| | p40, p41); 351| | } 352| | else if constexpr (N == 43) { 353| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 354| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42] = t; 355| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 356| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 357| | p40, p41, p42); 358| | } 359| | else if constexpr (N == 44) { 360| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 361| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, 362| | p43] = t; 363| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 364| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 365| | p40, p41, p42, p43); 366| | } 367| | else if constexpr (N == 45) { 368| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 369| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 370| | p44] = t; 371| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 372| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 373| | p40, p41, p42, p43, p44); 374| | } 375| | else if constexpr (N == 46) { 376| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 377| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 378| | p44, p45] = t; 379| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 380| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 381| | p40, p41, p42, p43, p44, p45); 382| | } 383| | else if constexpr (N == 47) { 384| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 385| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 386| | p44, p45, p46] = t; 387| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 388| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 389| | p40, p41, p42, p43, p44, p45, p46); 390| | } 391| | else if constexpr (N == 48) { 392| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 393| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 394| | p44, p45, p46, p47] = t; 395| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 396| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 397| | p40, p41, p42, p43, p44, p45, p46, p47); 398| | } 399| | else if constexpr (N == 49) { 400| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 401| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 402| | p44, p45, p46, p47, p48] = t; 403| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 404| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 405| | p40, p41, p42, p43, p44, p45, p46, p47, p48); 406| | } 407| | else if constexpr (N == 50) { 408| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 409| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 410| | p44, p45, p46, p47, p48, p49] = t; 411| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 412| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 413| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49); 414| | } 415| | else if constexpr (N == 51) { 416| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 417| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 418| | p44, p45, p46, p47, p48, p49, p50] = t; 419| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 420| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 421| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50); 422| | } 423| | else if constexpr (N == 52) { 424| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 425| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 426| | p44, p45, p46, p47, p48, p49, p50, p51] = t; 427| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 428| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 429| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51); 430| | } 431| | else if constexpr (N == 53) { 432| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 433| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 434| | p44, p45, p46, p47, p48, p49, p50, p51, p52] = t; 435| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 436| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 437| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52); 438| | } 439| | else if constexpr (N == 54) { 440| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 441| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 442| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53] = t; 443| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 444| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 445| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53); 446| | } 447| | else if constexpr (N == 55) { 448| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 449| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 450| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54] = t; 451| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 452| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 453| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54); 454| | } 455| | else if constexpr (N == 56) { 456| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 457| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 458| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55] = t; 459| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 460| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 461| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55); 462| | } 463| | else if constexpr (N == 57) { 464| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 465| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 466| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56] = t; 467| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 468| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 469| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56); 470| | } 471| | else if constexpr (N == 58) { 472| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 473| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 474| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57] = t; 475| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 476| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 477| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57); 478| | } 479| | else if constexpr (N == 59) { 480| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 481| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 482| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58] = t; 483| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 484| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 485| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58); 486| | } 487| | else if constexpr (N == 60) { 488| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 489| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 490| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59] = t; 491| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 492| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 493| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 494| | p59); 495| | } 496| | else if constexpr (N == 61) { 497| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 498| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 499| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60] = t; 500| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 501| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 502| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 503| | p59, p60); 504| | } 505| | else if constexpr (N == 62) { 506| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 507| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 508| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61] = t; 509| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 510| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 511| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 512| | p59, p60, p61); 513| | } 514| | else if constexpr (N == 63) { 515| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 516| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 517| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62] = t; 518| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 519| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 520| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 521| | p59, p60, p61, p62); 522| | } 523| | else if constexpr (N == 64) { 524| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 525| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 526| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63] = t; 527| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 528| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 529| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 530| | p59, p60, p61, p62, p63); 531| | } 532| | else if constexpr (N == 65) { 533| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 534| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 535| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, 536| | p64] = t; 537| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 538| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 539| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 540| | p59, p60, p61, p62, p63, p64); 541| | } 542| | else if constexpr (N == 66) { 543| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 544| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 545| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 546| | p65] = t; 547| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 548| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 549| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 550| | p59, p60, p61, p62, p63, p64, p65); 551| | } 552| | else if constexpr (N == 67) { 553| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 554| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 555| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 556| | p65, p66] = t; 557| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 558| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 559| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 560| | p59, p60, p61, p62, p63, p64, p65, p66); 561| | } 562| | else if constexpr (N == 68) { 563| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 564| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 565| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 566| | p65, p66, p67] = t; 567| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 568| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 569| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 570| | p59, p60, p61, p62, p63, p64, p65, p66, p67); 571| | } 572| | else if constexpr (N == 69) { 573| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 574| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 575| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 576| | p65, p66, p67, p68] = t; 577| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 578| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 579| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 580| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68); 581| | } 582| | else if constexpr (N == 70) { 583| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 584| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 585| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 586| | p65, p66, p67, p68, p69] = t; 587| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 588| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 589| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 590| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69); 591| | } 592| | else if constexpr (N == 71) { 593| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 594| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 595| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 596| | p65, p66, p67, p68, p69, p70] = t; 597| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 598| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 599| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 600| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70); 601| | } 602| | else if constexpr (N == 72) { 603| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 604| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 605| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 606| | p65, p66, p67, p68, p69, p70, p71] = t; 607| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 608| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 609| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 610| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71); 611| | } 612| | else if constexpr (N == 73) { 613| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 614| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 615| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 616| | p65, p66, p67, p68, p69, p70, p71, p72] = t; 617| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 618| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 619| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 620| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72); 621| | } 622| | else if constexpr (N == 74) { 623| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 624| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 625| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 626| | p65, p66, p67, p68, p69, p70, p71, p72, p73] = t; 627| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 628| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 629| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 630| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73); 631| | } 632| | else if constexpr (N == 75) { 633| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 634| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 635| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 636| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74] = t; 637| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 638| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 639| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 640| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74); 641| | } 642| | else if constexpr (N == 76) { 643| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 644| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 645| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 646| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75] = t; 647| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 648| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 649| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 650| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75); 651| | } 652| | else if constexpr (N == 77) { 653| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 654| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 655| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 656| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76] = t; 657| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 658| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 659| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 660| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76); 661| | } 662| | else if constexpr (N == 78) { 663| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 664| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 665| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 666| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77] = t; 667| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 668| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 669| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 670| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77); 671| | } 672| | else if constexpr (N == 79) { 673| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 674| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 675| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 676| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78] = t; 677| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 678| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 679| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 680| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 681| | p78); 682| | } 683| | else if constexpr (N == 80) { 684| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 685| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 686| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 687| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79] = t; 688| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 689| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 690| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 691| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 692| | p78, p79); 693| | } 694| | else if constexpr (N == 81) { 695| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 696| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 697| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 698| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80] = t; 699| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 700| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 701| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 702| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 703| | p78, p79, p80); 704| | } 705| | else if constexpr (N == 82) { 706| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 707| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 708| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 709| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81] = t; 710| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 711| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 712| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 713| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 714| | p78, p79, p80, p81); 715| | } 716| | else if constexpr (N == 83) { 717| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 718| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 719| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 720| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82] = t; 721| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 722| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 723| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 724| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 725| | p78, p79, p80, p81, p82); 726| | } 727| | else if constexpr (N == 84) { 728| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 729| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 730| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 731| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83] = t; 732| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 733| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 734| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 735| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 736| | p78, p79, p80, p81, p82, p83); 737| | } 738| | else if constexpr (N == 85) { 739| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 740| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 741| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 742| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84] = t; 743| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 744| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 745| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 746| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 747| | p78, p79, p80, p81, p82, p83, p84); 748| | } 749| | else if constexpr (N == 86) { 750| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 751| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 752| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 753| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, 754| | p85] = t; 755| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 756| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 757| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 758| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 759| | p78, p79, p80, p81, p82, p83, p84, p85); 760| | } 761| | else if constexpr (N == 87) { 762| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 763| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 764| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 765| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 766| | p86] = t; 767| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 768| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 769| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 770| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 771| | p78, p79, p80, p81, p82, p83, p84, p85, p86); 772| | } 773| | else if constexpr (N == 88) { 774| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 775| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 776| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 777| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 778| | p86, p87] = t; 779| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 780| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 781| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 782| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 783| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87); 784| | } 785| | else if constexpr (N == 89) { 786| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 787| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 788| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 789| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 790| | p86, p87, p88] = t; 791| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 792| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 793| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 794| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 795| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88); 796| | } 797| | else if constexpr (N == 90) { 798| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 799| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 800| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 801| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 802| | p86, p87, p88, p89] = t; 803| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 804| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 805| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 806| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 807| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89); 808| | } 809| | else if constexpr (N == 91) { 810| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 811| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 812| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 813| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 814| | p86, p87, p88, p89, p90] = t; 815| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 816| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 817| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 818| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 819| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90); 820| | } 821| | else if constexpr (N == 92) { 822| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 823| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 824| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 825| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 826| | p86, p87, p88, p89, p90, p91] = t; 827| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 828| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 829| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 830| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 831| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91); 832| | } 833| | else if constexpr (N == 93) { 834| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 835| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 836| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 837| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 838| | p86, p87, p88, p89, p90, p91, p92] = t; 839| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 840| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 841| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 842| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 843| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92); 844| | } 845| | else if constexpr (N == 94) { 846| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 847| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 848| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 849| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 850| | p86, p87, p88, p89, p90, p91, p92, p93] = t; 851| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 852| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 853| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 854| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 855| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93); 856| | } 857| | else if constexpr (N == 95) { 858| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 859| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 860| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 861| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 862| | p86, p87, p88, p89, p90, p91, p92, p93, p94] = t; 863| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 864| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 865| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 866| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 867| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94); 868| | } 869| | else if constexpr (N == 96) { 870| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 871| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 872| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 873| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 874| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95] = t; 875| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 876| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 877| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 878| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 879| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95); 880| | } 881| | else if constexpr (N == 97) { 882| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 883| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 884| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 885| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 886| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96] = t; 887| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 888| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 889| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 890| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 891| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96); 892| | } 893| | else if constexpr (N == 98) { 894| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 895| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 896| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 897| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 898| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97] = t; 899| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 900| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 901| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 902| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 903| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 904| | p97); 905| | } 906| | else if constexpr (N == 99) { 907| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 908| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 909| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 910| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 911| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98] = t; 912| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 913| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 914| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 915| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 916| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 917| | p97, p98); 918| | } 919| | else if constexpr (N == 100) { 920| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 921| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 922| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 923| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 924| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99] = t; 925| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 926| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 927| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 928| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 929| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 930| | p97, p98, p99); 931| | } 932| | else if constexpr (N == 101) { 933| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 934| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 935| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 936| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 937| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100] = t; 938| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 939| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 940| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 941| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 942| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 943| | p97, p98, p99, p100); 944| | } 945| | else if constexpr (N == 102) { 946| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 947| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 948| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 949| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 950| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101] = t; 951| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 952| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 953| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 954| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 955| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 956| | p97, p98, p99, p100, p101); 957| | } 958| | else if constexpr (N == 103) { 959| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 960| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 961| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 962| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 963| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102] = t; 964| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 965| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 966| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 967| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 968| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 969| | p97, p98, p99, p100, p101, p102); 970| | } 971| | else if constexpr (N == 104) { 972| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 973| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 974| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 975| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 976| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103] = t; 977| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 978| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 979| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 980| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 981| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 982| | p97, p98, p99, p100, p101, p102, p103); 983| | } 984| | else if constexpr (N == 105) { 985| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 986| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 987| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 988| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 989| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104] = t; 990| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 991| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 992| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 993| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 994| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 995| | p97, p98, p99, p100, p101, p102, p103, p104); 996| | } 997| | else if constexpr (N == 106) { 998| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 999| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1000| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1001| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1002| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1003| | p105] = t; 1004| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1005| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1006| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1007| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1008| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1009| | p97, p98, p99, p100, p101, p102, p103, p104, p105); 1010| | } 1011| | else if constexpr (N == 107) { 1012| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1013| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1014| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1015| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1016| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1017| | p105, p106] = t; 1018| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1019| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1020| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1021| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1022| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1023| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106); 1024| | } 1025| | else if constexpr (N == 108) { 1026| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1027| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1028| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1029| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1030| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1031| | p105, p106, p107] = t; 1032| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1033| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1034| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1035| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1036| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1037| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107); 1038| | } 1039| | else if constexpr (N == 109) { 1040| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1041| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1042| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1043| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1044| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1045| | p105, p106, p107, p108] = t; 1046| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1047| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1048| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1049| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1050| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1051| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108); 1052| | } 1053| | else if constexpr (N == 110) { 1054| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1055| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1056| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1057| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1058| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1059| | p105, p106, p107, p108, p109] = t; 1060| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1061| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1062| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1063| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1064| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1065| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109); 1066| | } 1067| | else if constexpr (N == 111) { 1068| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1069| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1070| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1071| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1072| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1073| | p105, p106, p107, p108, p109, p110] = t; 1074| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1075| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1076| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1077| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1078| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1079| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110); 1080| | } 1081| | else if constexpr (N == 112) { 1082| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1083| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1084| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1085| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1086| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1087| | p105, p106, p107, p108, p109, p110, p111] = t; 1088| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1089| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1090| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1091| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1092| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1093| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111); 1094| | } 1095| | else if constexpr (N == 113) { 1096| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1097| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1098| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1099| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1100| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1101| | p105, p106, p107, p108, p109, p110, p111, p112] = t; 1102| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1103| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1104| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1105| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1106| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1107| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112); 1108| | } 1109| | else if constexpr (N == 114) { 1110| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1111| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1112| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1113| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1114| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1115| | p105, p106, p107, p108, p109, p110, p111, p112, p113] = t; 1116| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1117| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1118| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1119| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1120| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1121| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1122| | p113); 1123| | } 1124| | else if constexpr (N == 115) { 1125| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1126| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1127| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1128| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1129| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1130| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114] = t; 1131| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1132| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1133| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1134| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1135| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1136| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1137| | p113, p114); 1138| | } 1139| | else if constexpr (N == 116) { 1140| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1141| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1142| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1143| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1144| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1145| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115] = t; 1146| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1147| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1148| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1149| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1150| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1151| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1152| | p113, p114, p115); 1153| | } 1154| | else if constexpr (N == 117) { 1155| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1156| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1157| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1158| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1159| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1160| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116] = t; 1161| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1162| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1163| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1164| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1165| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1166| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1167| | p113, p114, p115, p116); 1168| | } 1169| | else if constexpr (N == 118) { 1170| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1171| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1172| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1173| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1174| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1175| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117] = t; 1176| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1177| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1178| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1179| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1180| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1181| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1182| | p113, p114, p115, p116, p117); 1183| | } 1184| | else if constexpr (N == 119) { 1185| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1186| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1187| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1188| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1189| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1190| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118] = t; 1191| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1192| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1193| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1194| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1195| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1196| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1197| | p113, p114, p115, p116, p117, p118); 1198| | } 1199| | else if constexpr (N == 120) { 1200| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1201| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1202| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1203| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1204| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1205| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119] = t; 1206| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1207| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1208| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1209| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1210| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1211| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1212| | p113, p114, p115, p116, p117, p118, p119); 1213| | } 1214| | else if constexpr (N == 121) { 1215| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1216| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1217| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1218| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1219| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1220| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120] = t; 1221| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1222| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1223| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1224| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1225| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1226| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1227| | p113, p114, p115, p116, p117, p118, p119, p120); 1228| | } 1229| | else if constexpr (N == 122) { 1230| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1231| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1232| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1233| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1234| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1235| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121] = 1236| | t; 1237| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1238| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1239| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1240| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1241| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1242| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1243| | p113, p114, p115, p116, p117, p118, p119, p120, p121); 1244| | } 1245| | else if constexpr (N == 123) { 1246| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1247| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1248| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1249| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1250| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1251| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1252| | p122] = t; 1253| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1254| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1255| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1256| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1257| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1258| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1259| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122); 1260| | } 1261| | else if constexpr (N == 124) { 1262| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1263| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1264| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1265| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1266| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1267| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1268| | p122, p123] = t; 1269| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1270| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1271| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1272| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1273| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1274| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1275| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123); 1276| | } 1277| | else if constexpr (N == 125) { 1278| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1279| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1280| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1281| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1282| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1283| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1284| | p122, p123, p124] = t; 1285| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1286| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1287| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1288| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1289| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1290| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1291| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124); 1292| | } 1293| | else if constexpr (N == 126) { 1294| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1295| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1296| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1297| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1298| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1299| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1300| | p122, p123, p124, p125] = t; 1301| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1302| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1303| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1304| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1305| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1306| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1307| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125); 1308| | } 1309| | else if constexpr (N == 127) { 1310| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1311| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1312| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1313| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1314| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1315| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1316| | p122, p123, p124, p125, p126] = t; 1317| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1318| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1319| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1320| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1321| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1322| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1323| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126); 1324| | } 1325| | else if constexpr (N == 128) { 1326| | auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, p21, p22, 1327| | p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, p40, p41, p42, p43, 1328| | p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, p59, p60, p61, p62, p63, p64, 1329| | p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, p78, p79, p80, p81, p82, p83, p84, p85, 1330| | p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, 1331| | p105, p106, p107, p108, p109, p110, p111, p112, p113, p114, p115, p116, p117, p118, p119, p120, p121, 1332| | p122, p123, p124, p125, p126, p127] = t; 1333| | return glz::tie(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20, 1334| | p21, p22, p23, p24, p25, p26, p27, p28, p29, p30, p31, p32, p33, p34, p35, p36, p37, p38, p39, 1335| | p40, p41, p42, p43, p44, p45, p46, p47, p48, p49, p50, p51, p52, p53, p54, p55, p56, p57, p58, 1336| | p59, p60, p61, p62, p63, p64, p65, p66, p67, p68, p69, p70, p71, p72, p73, p74, p75, p76, p77, 1337| | p78, p79, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, 1338| | p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, 1339| | p113, p114, p115, p116, p117, p118, p119, p120, p121, p122, p123, p124, p125, p126, p127); 1340| | } 1341| 315| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 151| 66.7k| { 152| 66.7k| register_read_write_endpoint(path, value, reg); 153| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZNK3glz7jsonrpc5state8has_bodyEv: 28| 66.2k| bool has_body() const { return has_params; } _ZN3glz7jsonrpc11write_errorITkNS0_8is_stateERNS0_5stateEEEvOT_NS_3rpc7error_eERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEERKNS8_8optionalISE_EE: 76| 17.1k| { 77| 17.1k| if (state.notify()) { ------------------ | Branch (77:14): [True: 2.86k, False: 14.3k] ------------------ 78| 2.86k| return; // No response for notifications 79| 2.86k| } 80| | 81| 14.3k| state.response = R"({"jsonrpc":"2.0","error":{"code":)"; 82| 14.3k| state.response += std::to_string(static_cast(code)); 83| 14.3k| state.response += R"(,"message":)"; 84| 14.3k| state.response += write_json(message).value_or("\"\""); 85| 14.3k| if (data) { ------------------ | Branch (85:14): [True: 14.3k, False: 0] ------------------ 86| 14.3k| state.response += R"(,"data":)"; 87| 14.3k| state.response += write_json(*data).value_or("null"); 88| 14.3k| } 89| 14.3k| state.response += R"(},"id":)"; 90| 14.3k| state.response += write_json(state.id).value_or("null"); 91| 14.3k| state.response += "}"; 92| 14.3k| } _ZNK3glz7jsonrpc5state6notifyEv: 27| 51.8k| bool notify() const { return is_notification; } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS0_8is_stateERNS0_5stateEEEvOT0_: 63| 4.25k| { 64| 4.25k| if (state.notify()) { ------------------ | Branch (64:14): [True: 0, False: 4.25k] ------------------ 65| 0| return; // No response for notifications 66| 0| } 67| | 68| 4.25k| state.response = R"({"jsonrpc":"2.0","result":null,"id":)"; 69| 4.25k| state.response += write_json(state.id).value_or("null"); 70| 4.25k| state.response += "}"; 71| 4.25k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 241| 200k| { 242| 200k| register_read_write_endpoint(path, var, reg); 243| 200k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 127| 200k| { 128| 200k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 200k| if (state.has_body()) { 130| 200k| if (!jsonrpc::read_params(value, state)) { 131| 200k| return; 132| 200k| } 133| 200k| } 134| | 135| 200k| if (state.notify()) { 136| 200k| return; 137| 200k| } 138| | 139| 200k| if (!state.has_body()) { 140| 200k| jsonrpc::write_response(value, state); 141| 200k| } 142| 200k| else { 143| 200k| jsonrpc::write_response(state); 144| 200k| } 145| 200k| }; 146| 200k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_: 128| 814| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 814| if (state.has_body()) { ------------------ | Branch (129:17): [True: 313, False: 501] ------------------ 130| 313| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 230, False: 83] ------------------ 131| 230| return; 132| 230| } 133| 313| } 134| | 135| 584| if (state.notify()) { ------------------ | Branch (135:17): [True: 455, False: 129] ------------------ 136| 455| return; 137| 455| } 138| | 139| 129| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 68, False: 61] ------------------ 140| 68| jsonrpc::write_response(value, state); 141| 68| } 142| 61| else { 143| 61| jsonrpc::write_response(state); 144| 61| } 145| 129| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.92k| { 98| 1.92k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 642, False: 1.28k] ------------------ 99| 642| return true; // No params to read 100| 642| } 101| | 102| 1.28k| auto ec = read(std::forward(value), state.params_json); 103| 1.28k| if (ec) { ------------------ | Branch (103:14): [True: 640, False: 646] ------------------ 104| 640| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 640| return false; 106| 640| } 107| 646| return true; 108| 1.28k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 370| { 38| 370| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 370] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 370| std::string result_json; 43| 370| auto ec = write(std::forward(value), result_json); 44| 370| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 370] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 370| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 370| state.response += result_json; 55| 370| state.response += R"(,"id":)"; 56| 370| state.response += write_json(state.id).value_or("null"); 57| 370| state.response += "}"; 58| 370| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_: 271| 66.7k| { 272| 66.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 66.7k| static thread_local Input input{}; 274| 66.7k| input = {}; // reset to avoid stale optional/variant fields across calls 275| 66.7k| if (state.has_body()) { 276| 66.7k| if (!jsonrpc::read_params(input, state)) { 277| 66.7k| return; 278| 66.7k| } 279| 66.7k| } 280| | 281| 66.7k| if constexpr (std::same_as) { 282| 66.7k| (value.*func)(input); 283| | 284| 66.7k| if (state.notify()) { 285| 66.7k| return; 286| 66.7k| } 287| | 288| 66.7k| jsonrpc::write_response(state); 289| 66.7k| } 290| 66.7k| else { 291| 66.7k| if (state.notify()) { 292| 66.7k| std::ignore = (value.*func)(input); 293| 66.7k| return; 294| 66.7k| } 295| | 296| 66.7k| jsonrpc::write_response((value.*func)(input), state); 297| 66.7k| } 298| 66.7k| }; 299| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_ENUlONS_7jsonrpc5stateEE_clESM_: 272| 832| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 832| static thread_local Input input{}; 274| 832| input = {}; // reset to avoid stale optional/variant fields across calls 275| 832| if (state.has_body()) { ------------------ | Branch (275:17): [True: 476, False: 356] ------------------ 276| 476| if (!jsonrpc::read_params(input, state)) { ------------------ | Branch (276:20): [True: 187, False: 289] ------------------ 277| 187| return; 278| 187| } 279| 476| } 280| | 281| | if constexpr (std::same_as) { 282| | (value.*func)(input); 283| | 284| | if (state.notify()) { 285| | return; 286| | } 287| | 288| | jsonrpc::write_response(state); 289| | } 290| 645| else { 291| 645| if (state.notify()) { ------------------ | Branch (291:20): [True: 334, False: 311] ------------------ 292| 334| std::ignore = (value.*func)(input); 293| 334| return; 294| 334| } 295| | 296| 311| jsonrpc::write_response((value.*func)(input), state); 297| 311| } 298| 645| }; _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 311| { 38| 311| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 311] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 311| std::string result_json; 43| 311| auto ec = write(std::forward(value), result_json); 44| 311| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 311] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 311| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 311| state.response += result_json; 55| 311| state.response += R"(,"id":)"; 56| 311| state.response += write_json(state.id).value_or("null"); 57| 311| state.response += "}"; 58| 311| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_: 247| 66.7k| { 248| 66.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 249| 66.7k| if constexpr (std::same_as) { 250| 66.7k| (value.*func)(); 251| | 252| 66.7k| if (state.notify()) { 253| 66.7k| return; 254| 66.7k| } 255| | 256| 66.7k| jsonrpc::write_response(state); 257| 66.7k| } 258| 66.7k| else { 259| 66.7k| if (state.notify()) { 260| 66.7k| std::ignore = (value.*func)(); 261| 66.7k| return; 262| 66.7k| } 263| | 264| 66.7k| jsonrpc::write_response((value.*func)(), state); 265| 66.7k| } 266| 66.7k| }; 267| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_ENUlONS_7jsonrpc5stateEE_clESM_: 248| 316| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 249| 316| if constexpr (std::same_as) { 250| 316| (value.*func)(); 251| | 252| 316| if (state.notify()) { ------------------ | Branch (252:20): [True: 252, False: 64] ------------------ 253| 252| return; 254| 252| } 255| | 256| 64| jsonrpc::write_response(state); 257| | } 258| | else { 259| | if (state.notify()) { 260| | std::ignore = (value.*func)(); 261| | return; 262| | } 263| | 264| | jsonrpc::write_response((value.*func)(), state); 265| | } 266| 316| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_: 271| 66.7k| { 272| 66.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 66.7k| static thread_local Input input{}; 274| 66.7k| input = {}; // reset to avoid stale optional/variant fields across calls 275| 66.7k| if (state.has_body()) { 276| 66.7k| if (!jsonrpc::read_params(input, state)) { 277| 66.7k| return; 278| 66.7k| } 279| 66.7k| } 280| | 281| 66.7k| if constexpr (std::same_as) { 282| 66.7k| (value.*func)(input); 283| | 284| 66.7k| if (state.notify()) { 285| 66.7k| return; 286| 66.7k| } 287| | 288| 66.7k| jsonrpc::write_response(state); 289| 66.7k| } 290| 66.7k| else { 291| 66.7k| if (state.notify()) { 292| 66.7k| std::ignore = (value.*func)(input); 293| 66.7k| return; 294| 66.7k| } 295| | 296| 66.7k| jsonrpc::write_response((value.*func)(input), state); 297| 66.7k| } 298| 66.7k| }; 299| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_ENUlONS_7jsonrpc5stateEE_clESP_: 272| 1.09k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 1.09k| static thread_local Input input{}; 274| 1.09k| input = {}; // reset to avoid stale optional/variant fields across calls 275| 1.09k| if (state.has_body()) { ------------------ | Branch (275:17): [True: 557, False: 541] ------------------ 276| 557| if (!jsonrpc::read_params(input, state)) { ------------------ | Branch (276:20): [True: 496, False: 61] ------------------ 277| 496| return; 278| 496| } 279| 557| } 280| | 281| | if constexpr (std::same_as) { 282| | (value.*func)(input); 283| | 284| | if (state.notify()) { 285| | return; 286| | } 287| | 288| | jsonrpc::write_response(state); 289| | } 290| 602| else { 291| 602| if (state.notify()) { ------------------ | Branch (291:20): [True: 444, False: 158] ------------------ 292| 444| std::ignore = (value.*func)(input); 293| 444| return; 294| 444| } 295| | 296| 158| jsonrpc::write_response((value.*func)(input), state); 297| 158| } 298| 602| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.89k| { 98| 1.89k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 716, False: 1.17k] ------------------ 99| 716| return true; // No params to read 100| 716| } 101| | 102| 1.17k| auto ec = read(std::forward(value), state.params_json); 103| 1.17k| if (ec) { ------------------ | Branch (103:14): [True: 1.05k, False: 122] ------------------ 104| 1.05k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.05k| return false; 106| 1.05k| } 107| 122| return true; 108| 1.17k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 158| { 38| 158| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 158] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 158| std::string result_json; 43| 158| auto ec = write(std::forward(value), result_json); 44| 158| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 158] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 158| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 158| state.response += result_json; 55| 158| state.response += R"(,"id":)"; 56| 158| state.response += write_json(state.id).value_or("null"); 57| 158| state.response += "}"; 58| 158| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 151| 66.7k| { 152| 66.7k| register_read_write_endpoint(path, value, reg); 153| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 11.2k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 11.2k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 7.78k, False: 3.45k] ------------------ 130| 7.78k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 7.04k, False: 734] ------------------ 131| 7.04k| return; 132| 7.04k| } 133| 7.78k| } 134| | 135| 4.18k| if (state.notify()) { ------------------ | Branch (135:17): [True: 3.54k, False: 647] ------------------ 136| 3.54k| return; 137| 3.54k| } 138| | 139| 647| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 50, False: 597] ------------------ 140| 50| jsonrpc::write_response(value, state); 141| 50| } 142| 597| else { 143| 597| jsonrpc::write_response(state); 144| 597| } 145| 647| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 7.78k| { 98| 7.78k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 7.78k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 7.78k| auto ec = read(std::forward(value), state.params_json); 103| 7.78k| if (ec) { ------------------ | Branch (103:14): [True: 7.04k, False: 734] ------------------ 104| 7.04k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 7.04k| return false; 106| 7.04k| } 107| 734| return true; 108| 7.78k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 50| { 38| 50| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 50] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 50| std::string result_json; 43| 50| auto ec = write(std::forward(value), result_json); 44| 50| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 50] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 50| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 50| state.response += result_json; 55| 50| state.response += R"(,"id":)"; 56| 50| state.response += write_json(state.id).value_or("null"); 57| 50| state.response += "}"; 58| 50| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_: 241| 133k| { 242| 133k| register_read_write_endpoint(path, var, reg); 243| 133k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_: 127| 133k| { 128| 133k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 133k| if (state.has_body()) { 130| 133k| if (!jsonrpc::read_params(value, state)) { 131| 133k| return; 132| 133k| } 133| 133k| } 134| | 135| 133k| if (state.notify()) { 136| 133k| return; 137| 133k| } 138| | 139| 133k| if (!state.has_body()) { 140| 133k| jsonrpc::write_response(value, state); 141| 133k| } 142| 133k| else { 143| 133k| jsonrpc::write_response(state); 144| 133k| } 145| 133k| }; 146| 133k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_: 128| 545| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 545| if (state.has_body()) { ------------------ | Branch (129:17): [True: 260, False: 285] ------------------ 130| 260| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 167, False: 93] ------------------ 131| 167| return; 132| 167| } 133| 260| } 134| | 135| 378| if (state.notify()) { ------------------ | Branch (135:17): [True: 272, False: 106] ------------------ 136| 272| return; 137| 272| } 138| | 139| 106| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 33, False: 73] ------------------ 140| 33| jsonrpc::write_response(value, state); 141| 33| } 142| 73| else { 143| 73| jsonrpc::write_response(state); 144| 73| } 145| 106| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 3.15k| { 98| 3.15k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 1.93k, False: 1.22k] ------------------ 99| 1.93k| return true; // No params to read 100| 1.93k| } 101| | 102| 1.22k| auto ec = read(std::forward(value), state.params_json); 103| 1.22k| if (ec) { ------------------ | Branch (103:14): [True: 594, False: 627] ------------------ 104| 594| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 594| return false; 106| 594| } 107| 627| return true; 108| 1.22k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 654| { 38| 654| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 654] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 654| std::string result_json; 43| 654| auto ec = write(std::forward(value), result_json); 44| 654| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 654] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 654| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 654| state.response += result_json; 55| 654| state.response += R"(,"id":)"; 56| 654| state.response += write_json(state.id).value_or("null"); 57| 654| state.response += "}"; 58| 654| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 241| 133k| { 242| 133k| register_read_write_endpoint(path, var, reg); 243| 133k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 127| 133k| { 128| 133k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 133k| if (state.has_body()) { 130| 133k| if (!jsonrpc::read_params(value, state)) { 131| 133k| return; 132| 133k| } 133| 133k| } 134| | 135| 133k| if (state.notify()) { 136| 133k| return; 137| 133k| } 138| | 139| 133k| if (!state.has_body()) { 140| 133k| jsonrpc::write_response(value, state); 141| 133k| } 142| 133k| else { 143| 133k| jsonrpc::write_response(state); 144| 133k| } 145| 133k| }; 146| 133k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_: 128| 1.15k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 1.15k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 607, False: 550] ------------------ 130| 607| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 170, False: 437] ------------------ 131| 170| return; 132| 170| } 133| 607| } 134| | 135| 987| if (state.notify()) { ------------------ | Branch (135:17): [True: 554, False: 433] ------------------ 136| 554| return; 137| 554| } 138| | 139| 433| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 25, False: 408] ------------------ 140| 25| jsonrpc::write_response(value, state); 141| 25| } 142| 408| else { 143| 408| jsonrpc::write_response(state); 144| 408| } 145| 433| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 607| { 98| 607| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 607] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 607| auto ec = read(std::forward(value), state.params_json); 103| 607| if (ec) { ------------------ | Branch (103:14): [True: 170, False: 437] ------------------ 104| 170| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 170| return false; 106| 170| } 107| 437| return true; 108| 607| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 1.91k| { 38| 1.91k| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 1.91k] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 1.91k| std::string result_json; 43| 1.91k| auto ec = write(std::forward(value), result_json); 44| 1.91k| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 1.91k] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 1.91k| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 1.91k| state.response += result_json; 55| 1.91k| state.response += R"(,"id":)"; 56| 1.91k| state.response += write_json(state.id).value_or("null"); 57| 1.91k| state.response += "}"; 58| 1.91k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 212| 66.7k| { 213| 66.7k| register_read_write_endpoint(path, obj, reg); 214| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 1.12k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 1.12k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 222, False: 905] ------------------ 130| 222| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 207, False: 15] ------------------ 131| 207| return; 132| 207| } 133| 222| } 134| | 135| 920| if (state.notify()) { ------------------ | Branch (135:17): [True: 774, False: 146] ------------------ 136| 774| return; 137| 774| } 138| | 139| 146| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 133, False: 13] ------------------ 140| 133| jsonrpc::write_response(value, state); 141| 133| } 142| 13| else { 143| 13| jsonrpc::write_response(state); 144| 13| } 145| 146| }; _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 247| { 38| 247| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 247] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 247| std::string result_json; 43| 247| auto ec = write(std::forward(value), result_json); 44| 247| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 247] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 247| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 247| state.response += result_json; 55| 247| state.response += R"(,"id":)"; 56| 247| state.response += write_json(state.id).value_or("null"); 57| 247| state.response += "}"; 58| 247| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 212| 66.7k| { 213| 66.7k| register_read_write_endpoint(path, obj, reg); 214| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 2.58k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.58k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.62k, False: 955] ------------------ 130| 1.62k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.38k, False: 237] ------------------ 131| 1.38k| return; 132| 1.38k| } 133| 1.62k| } 134| | 135| 1.19k| if (state.notify()) { ------------------ | Branch (135:17): [True: 926, False: 266] ------------------ 136| 926| return; 137| 926| } 138| | 139| 266| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 73, False: 193] ------------------ 140| 73| jsonrpc::write_response(value, state); 141| 73| } 142| 193| else { 143| 193| jsonrpc::write_response(state); 144| 193| } 145| 266| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.62k| { 98| 1.62k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.62k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.62k| auto ec = read(std::forward(value), state.params_json); 103| 1.62k| if (ec) { ------------------ | Branch (103:14): [True: 1.38k, False: 237] ------------------ 104| 1.38k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.38k| return false; 106| 1.38k| } 107| 237| return true; 108| 1.62k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 73| { 38| 73| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 73] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 73| std::string result_json; 43| 73| auto ec = write(std::forward(value), result_json); 44| 73| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 73] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 73| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 73| state.response += result_json; 55| 73| state.response += R"(,"id":)"; 56| 73| state.response += write_json(state.id).value_or("null"); 57| 73| state.response += "}"; 58| 73| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 241| 66.7k| { 242| 66.7k| register_read_write_endpoint(path, var, reg); 243| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_: 128| 3.38k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 3.38k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 2.03k, False: 1.34k] ------------------ 130| 2.03k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.59k, False: 441] ------------------ 131| 1.59k| return; 132| 1.59k| } 133| 2.03k| } 134| | 135| 1.78k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.22k, False: 558] ------------------ 136| 1.22k| return; 137| 1.22k| } 138| | 139| 558| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 125, False: 433] ------------------ 140| 125| jsonrpc::write_response(value, state); 141| 125| } 142| 433| else { 143| 433| jsonrpc::write_response(state); 144| 433| } 145| 558| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 2.03k| { 98| 2.03k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 2.03k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 2.03k| auto ec = read(std::forward(value), state.params_json); 103| 2.03k| if (ec) { ------------------ | Branch (103:14): [True: 1.59k, False: 441] ------------------ 104| 1.59k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.59k| return false; 106| 1.59k| } 107| 441| return true; 108| 2.03k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 125| { 38| 125| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 125] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 125| std::string result_json; 43| 125| auto ec = write(std::forward(value), result_json); 44| 125| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 125] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 125| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 125| state.response += result_json; 55| 125| state.response += R"(,"id":)"; 56| 125| state.response += write_json(state.id).value_or("null"); 57| 125| state.response += "}"; 58| 125| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 241| 66.7k| { 242| 66.7k| register_read_write_endpoint(path, var, reg); 243| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clEST_: 128| 2.97k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.97k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.91k, False: 1.05k] ------------------ 130| 1.91k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.57k, False: 339] ------------------ 131| 1.57k| return; 132| 1.57k| } 133| 1.91k| } 134| | 135| 1.39k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.06k, False: 326] ------------------ 136| 1.06k| return; 137| 1.06k| } 138| | 139| 326| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 53, False: 273] ------------------ 140| 53| jsonrpc::write_response(value, state); 141| 53| } 142| 273| else { 143| 273| jsonrpc::write_response(state); 144| 273| } 145| 326| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.91k| { 98| 1.91k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.91k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.91k| auto ec = read(std::forward(value), state.params_json); 103| 1.91k| if (ec) { ------------------ | Branch (103:14): [True: 1.57k, False: 339] ------------------ 104| 1.57k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.57k| return false; 106| 1.57k| } 107| 339| return true; 108| 1.91k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 53| { 38| 53| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 53] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 53| std::string result_json; 43| 53| auto ec = write(std::forward(value), result_json); 44| 53| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 53] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 53| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 53| state.response += result_json; 55| 53| state.response += R"(,"id":)"; 56| 53| state.response += write_json(state.id).value_or("null"); 57| 53| state.response += "}"; 58| 53| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 241| 66.7k| { 242| 66.7k| register_read_write_endpoint(path, var, reg); 243| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 3.41k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 3.41k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 2.08k, False: 1.32k] ------------------ 130| 2.08k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 350, False: 1.73k] ------------------ 131| 350| return; 132| 350| } 133| 2.08k| } 134| | 135| 3.06k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.44k, False: 1.61k] ------------------ 136| 1.44k| return; 137| 1.44k| } 138| | 139| 1.61k| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 48, False: 1.56k] ------------------ 140| 48| jsonrpc::write_response(value, state); 141| 48| } 142| 1.56k| else { 143| 1.56k| jsonrpc::write_response(state); 144| 1.56k| } 145| 1.61k| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 2.08k| { 98| 2.08k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 2.08k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 2.08k| auto ec = read(std::forward(value), state.params_json); 103| 2.08k| if (ec) { ------------------ | Branch (103:14): [True: 350, False: 1.73k] ------------------ 104| 350| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 350| return false; 106| 350| } 107| 1.73k| return true; 108| 2.08k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 48| { 38| 48| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 48] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 48| std::string result_json; 43| 48| auto ec = write(std::forward(value), result_json); 44| 48| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 48] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 48| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 48| state.response += result_json; 55| 48| state.response += R"(,"id":)"; 56| 48| state.response += write_json(state.id).value_or("null"); 57| 48| state.response += "}"; 58| 48| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 241| 66.7k| { 242| 66.7k| register_read_write_endpoint(path, var, reg); 243| 66.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 127| 66.7k| { 128| 66.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 66.7k| if (state.has_body()) { 130| 66.7k| if (!jsonrpc::read_params(value, state)) { 131| 66.7k| return; 132| 66.7k| } 133| 66.7k| } 134| | 135| 66.7k| if (state.notify()) { 136| 66.7k| return; 137| 66.7k| } 138| | 139| 66.7k| if (!state.has_body()) { 140| 66.7k| jsonrpc::write_response(value, state); 141| 66.7k| } 142| 66.7k| else { 143| 66.7k| jsonrpc::write_response(state); 144| 66.7k| } 145| 66.7k| }; 146| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clESP_: 128| 2.02k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.02k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.10k, False: 920] ------------------ 130| 1.10k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 709, False: 397] ------------------ 131| 709| return; 132| 709| } 133| 1.10k| } 134| | 135| 1.31k| if (state.notify()) { ------------------ | Branch (135:17): [True: 907, False: 410] ------------------ 136| 907| return; 137| 907| } 138| | 139| 410| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 73, False: 337] ------------------ 140| 73| jsonrpc::write_response(value, state); 141| 73| } 142| 337| else { 143| 337| jsonrpc::write_response(state); 144| 337| } 145| 410| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.10k| { 98| 1.10k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.10k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.10k| auto ec = read(std::forward(value), state.params_json); 103| 1.10k| if (ec) { ------------------ | Branch (103:14): [True: 709, False: 397] ------------------ 104| 709| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 709| return false; 106| 709| } 107| 397| return true; 108| 1.10k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 73| { 38| 73| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 73] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 73| std::string result_json; 43| 73| auto ec = write(std::forward(value), result_json); 44| 73| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 73] ------------------ 45| | // Write error response 46| 0| state.response = 47| 0| R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":"Failed to serialize result"},"id":)"; 48| 0| state.response += write_json(state.id).value_or("null"); 49| 0| state.response += "}"; 50| 0| return; 51| 0| } 52| | 53| 73| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 73| state.response += result_json; 55| 73| state.response += R"(,"id":)"; 56| 73| state.response += write_json(state.id).value_or("null"); 57| 73| state.response += "}"; 58| 73| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 66.7k| { 181| 66.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 66.7k| static thread_local std::decay_t params{}; 183| 66.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 66.7k| if (!jsonrpc::read_params(params, state)) { 185| 66.7k| return; 186| 66.7k| } 187| | 188| 66.7k| using Result = std::invoke_result_t; 189| | 190| 66.7k| if (state.notify()) { 191| 66.7k| if constexpr (std::same_as) { 192| 66.7k| func(params); 193| 66.7k| } 194| 66.7k| else { 195| 66.7k| std::ignore = func(params); 196| 66.7k| } 197| 66.7k| return; 198| 66.7k| } 199| 66.7k| if constexpr (std::same_as) { 200| 66.7k| func(params); 201| 66.7k| jsonrpc::write_response(state); 202| 66.7k| } 203| 66.7k| else { 204| 66.7k| auto ret = func(params); 205| 66.7k| jsonrpc::write_response(ret, state); 206| 66.7k| } 207| 66.7k| }; 208| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_: 181| 1.13k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 1.13k| static thread_local std::decay_t params{}; 183| 1.13k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 1.13k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 223, False: 916] ------------------ 185| 223| return; 186| 223| } 187| | 188| 916| using Result = std::invoke_result_t; 189| | 190| 916| if (state.notify()) { ------------------ | Branch (190:17): [True: 614, False: 302] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 614| else { 195| 614| std::ignore = func(params); 196| 614| } 197| 614| return; 198| 614| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 302| else { 204| 302| auto ret = func(params); 205| 302| jsonrpc::write_response(ret, state); 206| 302| } 207| 302| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_: 180| 66.7k| { 181| 66.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 66.7k| static thread_local std::decay_t params{}; 183| 66.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 66.7k| if (!jsonrpc::read_params(params, state)) { 185| 66.7k| return; 186| 66.7k| } 187| | 188| 66.7k| using Result = std::invoke_result_t; 189| | 190| 66.7k| if (state.notify()) { 191| 66.7k| if constexpr (std::same_as) { 192| 66.7k| func(params); 193| 66.7k| } 194| 66.7k| else { 195| 66.7k| std::ignore = func(params); 196| 66.7k| } 197| 66.7k| return; 198| 66.7k| } 199| 66.7k| if constexpr (std::same_as) { 200| 66.7k| func(params); 201| 66.7k| jsonrpc::write_response(state); 202| 66.7k| } 203| 66.7k| else { 204| 66.7k| auto ret = func(params); 205| 66.7k| jsonrpc::write_response(ret, state); 206| 66.7k| } 207| 66.7k| }; 208| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_ENUlONS_7jsonrpc5stateEE_clESR_: 181| 2.89k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 2.89k| static thread_local std::decay_t params{}; 183| 2.89k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 2.89k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 427, False: 2.46k] ------------------ 185| 427| return; 186| 427| } 187| | 188| 2.46k| using Result = std::invoke_result_t; 189| | 190| 2.46k| if (state.notify()) { ------------------ | Branch (190:17): [True: 1.84k, False: 621] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 1.84k| else { 195| 1.84k| std::ignore = func(params); 196| 1.84k| } 197| 1.84k| return; 198| 1.84k| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 621| else { 204| 621| auto ret = func(params); 205| 621| jsonrpc::write_response(ret, state); 206| 621| } 207| 621| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 66.7k| { 181| 66.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 66.7k| static thread_local std::decay_t params{}; 183| 66.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 66.7k| if (!jsonrpc::read_params(params, state)) { 185| 66.7k| return; 186| 66.7k| } 187| | 188| 66.7k| using Result = std::invoke_result_t; 189| | 190| 66.7k| if (state.notify()) { 191| 66.7k| if constexpr (std::same_as) { 192| 66.7k| func(params); 193| 66.7k| } 194| 66.7k| else { 195| 66.7k| std::ignore = func(params); 196| 66.7k| } 197| 66.7k| return; 198| 66.7k| } 199| 66.7k| if constexpr (std::same_as) { 200| 66.7k| func(params); 201| 66.7k| jsonrpc::write_response(state); 202| 66.7k| } 203| 66.7k| else { 204| 66.7k| auto ret = func(params); 205| 66.7k| jsonrpc::write_response(ret, state); 206| 66.7k| } 207| 66.7k| }; 208| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESP_: 181| 1.11k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 1.11k| static thread_local std::decay_t params{}; 183| 1.11k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 1.11k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 354, False: 762] ------------------ 185| 354| return; 186| 354| } 187| | 188| 762| using Result = std::invoke_result_t; 189| | 190| 762| if (state.notify()) { ------------------ | Branch (190:17): [True: 648, False: 114] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 648| else { 195| 648| std::ignore = func(params); 196| 648| } 197| 648| return; 198| 648| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 114| else { 204| 114| auto ret = func(params); 205| 114| jsonrpc::write_response(ret, state); 206| 114| } 207| 114| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 66.7k| { 181| 66.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 66.7k| static thread_local std::decay_t params{}; 183| 66.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 66.7k| if (!jsonrpc::read_params(params, state)) { 185| 66.7k| return; 186| 66.7k| } 187| | 188| 66.7k| using Result = std::invoke_result_t; 189| | 190| 66.7k| if (state.notify()) { 191| 66.7k| if constexpr (std::same_as) { 192| 66.7k| func(params); 193| 66.7k| } 194| 66.7k| else { 195| 66.7k| std::ignore = func(params); 196| 66.7k| } 197| 66.7k| return; 198| 66.7k| } 199| 66.7k| if constexpr (std::same_as) { 200| 66.7k| func(params); 201| 66.7k| jsonrpc::write_response(state); 202| 66.7k| } 203| 66.7k| else { 204| 66.7k| auto ret = func(params); 205| 66.7k| jsonrpc::write_response(ret, state); 206| 66.7k| } 207| 66.7k| }; 208| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESQ_: 181| 6.29k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 6.29k| static thread_local std::decay_t params{}; 183| 6.29k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 6.29k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 2.04k, False: 4.25k] ------------------ 185| 2.04k| return; 186| 2.04k| } 187| | 188| 4.25k| using Result = std::invoke_result_t; 189| | 190| 4.25k| if (state.notify()) { ------------------ | Branch (190:17): [True: 2.36k, False: 1.88k] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 2.36k| else { 195| 2.36k| std::ignore = func(params); 196| 2.36k| } 197| 2.36k| return; 198| 2.36k| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 1.88k| else { 204| 1.88k| auto ret = func(params); 205| 1.88k| jsonrpc::write_response(ret, state); 206| 1.88k| } 207| 1.88k| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS3_9allocatorIdEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 6.29k| { 98| 6.29k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 2.37k, False: 3.92k] ------------------ 99| 2.37k| return true; // No params to read 100| 2.37k| } 101| | 102| 3.92k| auto ec = read(std::forward(value), state.params_json); 103| 3.92k| if (ec) { ------------------ | Branch (103:14): [True: 2.04k, False: 1.87k] ------------------ 104| 2.04k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 2.04k| return false; 106| 2.04k| } 107| 1.87k| return true; 108| 3.92k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 157| 66.7k| { 158| 66.7k| if constexpr (std::same_as) { 159| 66.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 160| 66.7k| func(); 161| 66.7k| if (state.notify()) { 162| 66.7k| return; 163| 66.7k| } 164| 66.7k| jsonrpc::write_response(state); 165| 66.7k| }; 166| | } 167| | else { 168| | reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 169| | if (state.notify()) { 170| | std::ignore = func(); 171| | return; 172| | } 173| | jsonrpc::write_response(func(), state); 174| | }; 175| | } 176| 66.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_: 159| 550| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 160| 550| func(); 161| 550| if (state.notify()) { ------------------ | Branch (161:20): [True: 312, False: 238] ------------------ 162| 312| return; 163| 312| } 164| 238| jsonrpc::write_response(state); 165| 238| }; jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 306| 66.7k| { 307| 66.7k| using impl = registry_impl; 308| | 309| 66.7k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 310| 66.7k| impl::register_endpoint(root, value, *this); 311| 66.7k| } 312| | 313| 66.7k| register_members(value); 314| 66.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 175| 66.7k| { 176| 66.7k| using namespace glz::detail; 177| 66.7k| static constexpr auto N = reflect::size; 178| | 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| 66.7k| } 183| 66.7k| else { 184| 66.7k| return nullptr; 185| 66.7k| } 186| 66.7k| }(); 187| | 188| 66.7k| using impl = registry_impl; 189| | 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| 66.7k| if constexpr (std::is_invocable_v) { 214| 66.7k| using Result = std::decay_t>; 215| 66.7k| impl::template register_function_endpoint(full_key, func, *this); 216| 66.7k| } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| 66.7k| } 226| 66.7k| else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| 66.7k| using Tuple = function_ptr_args_t>; 229| 66.7k| constexpr auto N = glz::tuple_size_v; 230| 66.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 235| 66.7k| } 236| 66.7k| else if constexpr (std::is_pointer_v> && 237| 66.7k| (glaze_object_t>> || 238| 66.7k| reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| 66.7k| if (func) { // Only traverse if pointer is valid 241| 66.7k| on>, full_key>(*func); 242| 66.7k| impl::template register_object_endpoint>>( 243| 66.7k| full_key, *func, *this); 244| 66.7k| } 245| | // else: skip registration for null pointers - no endpoints created 246| 66.7k| } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| 66.7k| } 252| 66.7k| else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| 66.7k| impl::template register_value_endpoint>(full_key, func, *this); 255| 66.7k| } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| 66.7k| if constexpr (std::is_void_v) { 265| 66.7k| if constexpr (n_args == 0) { 266| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 267| 66.7k| } 268| 66.7k| else if constexpr (n_args == 1) { 269| 66.7k| using Input = std::decay_t>; 270| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 271| 66.7k| func, *this); 272| 66.7k| } 273| 66.7k| else { 274| 66.7k| static_assert(false_v, "function cannot have more than one input"); 275| 66.7k| } 276| 66.7k| } 277| 66.7k| else { 278| | // Member function pointers 279| 66.7k| if constexpr (n_args == 0) { 280| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 281| 66.7k| } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| 66.7k| } 287| 66.7k| else { 288| 66.7k| static_assert(false_v, "function cannot have more than one input"); 289| 66.7k| } 290| 66.7k| } 291| 66.7k| } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); 299| 66.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| | if constexpr (reflectable && requires { to_tie(value); }) { 181| | return to_tie(value); 182| | } 183| 66.7k| else { 184| 66.7k| return nullptr; 185| 66.7k| } 186| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| | if constexpr (reflectable) { 193| | return get_member(value, get(t)); 194| | } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| 66.7k| else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| 66.7k| } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| | if constexpr (reflectable) { 193| | return get_member(value, get(t)); 194| | } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| 66.7k| if constexpr (std::is_void_v) { 265| 66.7k| if constexpr (n_args == 0) { 266| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| | if constexpr (reflectable) { 193| | return get_member(value, get(t)); 194| | } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| 66.7k| else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| 66.7k| } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| | if constexpr (reflectable) { 193| | return get_member(value, get(t)); 194| | } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 306| 66.7k| { 307| 66.7k| using impl = registry_impl; 308| | 309| 66.7k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 310| 66.7k| impl::register_endpoint(root, value, *this); 311| 66.7k| } 312| | 313| 66.7k| register_members(value); 314| 66.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 175| 66.7k| { 176| 66.7k| using namespace glz::detail; 177| 66.7k| static constexpr auto N = reflect::size; 178| | 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| 66.7k| } 183| 66.7k| else { 184| 66.7k| return nullptr; 185| 66.7k| } 186| 66.7k| }(); 187| | 188| 66.7k| using impl = registry_impl; 189| | 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| 66.7k| if constexpr (std::is_invocable_v) { 214| 66.7k| using Result = std::decay_t>; 215| 66.7k| impl::template register_function_endpoint(full_key, func, *this); 216| 66.7k| } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| 66.7k| } 226| 66.7k| else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| 66.7k| using Tuple = function_ptr_args_t>; 229| 66.7k| constexpr auto N = glz::tuple_size_v; 230| 66.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 235| 66.7k| } 236| 66.7k| else if constexpr (std::is_pointer_v> && 237| 66.7k| (glaze_object_t>> || 238| 66.7k| reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| 66.7k| if (func) { // Only traverse if pointer is valid 241| 66.7k| on>, full_key>(*func); 242| 66.7k| impl::template register_object_endpoint>>( 243| 66.7k| full_key, *func, *this); 244| 66.7k| } 245| | // else: skip registration for null pointers - no endpoints created 246| 66.7k| } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| 66.7k| } 252| 66.7k| else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| 66.7k| impl::template register_value_endpoint>(full_key, func, *this); 255| 66.7k| } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| 66.7k| if constexpr (std::is_void_v) { 265| 66.7k| if constexpr (n_args == 0) { 266| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 267| 66.7k| } 268| 66.7k| else if constexpr (n_args == 1) { 269| 66.7k| using Input = std::decay_t>; 270| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 271| 66.7k| func, *this); 272| 66.7k| } 273| 66.7k| else { 274| 66.7k| static_assert(false_v, "function cannot have more than one input"); 275| 66.7k| } 276| 66.7k| } 277| 66.7k| else { 278| | // Member function pointers 279| 66.7k| if constexpr (n_args == 0) { 280| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 281| 66.7k| } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| 66.7k| } 287| 66.7k| else { 288| 66.7k| static_assert(false_v, "function cannot have more than one input"); 289| 66.7k| } 290| 66.7k| } 291| 66.7k| } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); 299| 66.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| | } 183| | else { 184| | return nullptr; 185| | } 186| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_: 306| 66.7k| { 307| 66.7k| using impl = registry_impl; 308| | 309| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 310| | impl::register_endpoint(root, value, *this); 311| | } 312| | 313| 66.7k| register_members(value); 314| 66.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_: 175| 66.7k| { 176| 66.7k| using namespace glz::detail; 177| 66.7k| static constexpr auto N = reflect::size; 178| | 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| 66.7k| } 183| 66.7k| else { 184| 66.7k| return nullptr; 185| 66.7k| } 186| 66.7k| }(); 187| | 188| 66.7k| using impl = registry_impl; 189| | 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| 66.7k| if constexpr (std::is_invocable_v) { 214| 66.7k| using Result = std::decay_t>; 215| 66.7k| impl::template register_function_endpoint(full_key, func, *this); 216| 66.7k| } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| 66.7k| } 226| 66.7k| else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| 66.7k| using Tuple = function_ptr_args_t>; 229| 66.7k| constexpr auto N = glz::tuple_size_v; 230| 66.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 235| 66.7k| } 236| 66.7k| else if constexpr (std::is_pointer_v> && 237| 66.7k| (glaze_object_t>> || 238| 66.7k| reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| 66.7k| if (func) { // Only traverse if pointer is valid 241| 66.7k| on>, full_key>(*func); 242| 66.7k| impl::template register_object_endpoint>>( 243| 66.7k| full_key, *func, *this); 244| 66.7k| } 245| | // else: skip registration for null pointers - no endpoints created 246| 66.7k| } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| 66.7k| } 252| 66.7k| else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| 66.7k| impl::template register_value_endpoint>(full_key, func, *this); 255| 66.7k| } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| 66.7k| if constexpr (std::is_void_v) { 265| 66.7k| if constexpr (n_args == 0) { 266| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 267| 66.7k| } 268| 66.7k| else if constexpr (n_args == 1) { 269| 66.7k| using Input = std::decay_t>; 270| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 271| 66.7k| func, *this); 272| 66.7k| } 273| 66.7k| else { 274| 66.7k| static_assert(false_v, "function cannot have more than one input"); 275| 66.7k| } 276| 66.7k| } 277| 66.7k| else { 278| | // Member function pointers 279| 66.7k| if constexpr (n_args == 0) { 280| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 281| 66.7k| } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| 66.7k| } 287| 66.7k| else { 288| 66.7k| static_assert(false_v, "function cannot have more than one input"); 289| 66.7k| } 290| 66.7k| } 291| 66.7k| } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); 299| 66.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlvE_clEv: 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| | } 183| | else { 184| | return nullptr; 185| | } 186| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_: 306| 66.7k| { 307| 66.7k| using impl = registry_impl; 308| | 309| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 310| | impl::register_endpoint(root, value, *this); 311| | } 312| | 313| 66.7k| register_members(value); 314| 66.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_: 175| 66.7k| { 176| 66.7k| using namespace glz::detail; 177| 66.7k| static constexpr auto N = reflect::size; 178| | 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| 66.7k| } 183| 66.7k| else { 184| 66.7k| return nullptr; 185| 66.7k| } 186| 66.7k| }(); 187| | 188| 66.7k| using impl = registry_impl; 189| | 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| 66.7k| if constexpr (std::is_invocable_v) { 214| 66.7k| using Result = std::decay_t>; 215| 66.7k| impl::template register_function_endpoint(full_key, func, *this); 216| 66.7k| } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| 66.7k| } 226| 66.7k| else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| 66.7k| using Tuple = function_ptr_args_t>; 229| 66.7k| constexpr auto N = glz::tuple_size_v; 230| 66.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 235| 66.7k| } 236| 66.7k| else if constexpr (std::is_pointer_v> && 237| 66.7k| (glaze_object_t>> || 238| 66.7k| reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| 66.7k| if (func) { // Only traverse if pointer is valid 241| 66.7k| on>, full_key>(*func); 242| 66.7k| impl::template register_object_endpoint>>( 243| 66.7k| full_key, *func, *this); 244| 66.7k| } 245| | // else: skip registration for null pointers - no endpoints created 246| 66.7k| } 247| 66.7k| else if constexpr (glaze_object_t> || reflectable>) { 248| 66.7k| on, full_key>(func); 249| | 250| 66.7k| impl::template register_object_endpoint>(full_key, func, *this); 251| 66.7k| } 252| 66.7k| else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| 66.7k| impl::template register_value_endpoint>(full_key, func, *this); 255| 66.7k| } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| 66.7k| if constexpr (std::is_member_function_pointer_v>) { 260| 66.7k| using F = std::decay_t; 261| 66.7k| using Ret = typename return_type::type; 262| 66.7k| using Tuple = typename inputs_as_tuple::type; 263| 66.7k| constexpr auto n_args = glz::tuple_size_v; 264| 66.7k| if constexpr (std::is_void_v) { 265| 66.7k| if constexpr (n_args == 0) { 266| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 267| 66.7k| } 268| 66.7k| else if constexpr (n_args == 1) { 269| 66.7k| using Input = std::decay_t>; 270| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 271| 66.7k| func, *this); 272| 66.7k| } 273| 66.7k| else { 274| 66.7k| static_assert(false_v, "function cannot have more than one input"); 275| 66.7k| } 276| 66.7k| } 277| 66.7k| else { 278| | // Member function pointers 279| 66.7k| if constexpr (n_args == 0) { 280| 66.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 281| 66.7k| } 282| 66.7k| else if constexpr (n_args == 1) { 283| 66.7k| using Input = std::decay_t>; 284| 66.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 285| 66.7k| func, *this); 286| 66.7k| } 287| 66.7k| else { 288| 66.7k| static_assert(false_v, "function cannot have more than one input"); 289| 66.7k| } 290| 66.7k| } 291| 66.7k| } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); 299| 66.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlvE_clEv: 179| 66.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 180| 66.7k| if constexpr (reflectable && requires { to_tie(value); }) { 181| 66.7k| return to_tie(value); 182| | } 183| | else { 184| | return nullptr; 185| | } 186| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| 66.7k| else { 257| 66.7k| static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| 66.7k| else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| 66.7k| impl::template register_variable_endpoint>(full_key, func, *this); 296| 66.7k| } 297| 66.7k| } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| | if constexpr (std::is_invocable_v) { 214| | using Result = std::decay_t>; 215| | impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| 66.7k| else if constexpr (is_invocable_concrete>) { 218| 66.7k| using Tuple = invocable_args_t>; 219| 66.7k| constexpr auto N = glz::tuple_size_v; 220| 66.7k| static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| 66.7k| using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| 66.7k| impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDav: 190| 66.7k| for_each([&]() { 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| 66.7k| } 195| 66.7k| else { 196| 66.7k| return get_member(value, get(reflect::values)); 197| 66.7k| } 198| 66.7k| }(); 199| | 200| 66.7k| static constexpr auto key = reflect::keys[I]; 201| | 202| 66.7k| static constexpr std::string_view full_key = [&] { 203| 66.7k| if constexpr (parent == detail::empty_path) { 204| 66.7k| return join_v, key>; 205| 66.7k| } 206| 66.7k| else { 207| 66.7k| return join_v, key>; 208| 66.7k| } 209| 66.7k| }(); 210| | 211| | // This logic chain should match glz::cli_menu 212| 66.7k| using Func = decltype(func); 213| 66.7k| if constexpr (std::is_invocable_v) { 214| 66.7k| using Result = std::decay_t>; 215| 66.7k| impl::template register_function_endpoint(full_key, func, *this); 216| | } 217| | else if constexpr (is_invocable_concrete>) { 218| | using Tuple = invocable_args_t>; 219| | constexpr auto N = glz::tuple_size_v; 220| | static_assert(N == 1, "Only one input is allowed for your function"); 221| | 222| | using Params = glz::tuple_element_t<0, Tuple>; 223| | 224| | impl::template register_param_function_endpoint(full_key, func, *this); 225| | } 226| | else if constexpr (is_function_ptr_invocable>) { 227| | // Handle function pointers with arguments (e.g., void(*)(int)) 228| | using Tuple = function_ptr_args_t>; 229| | constexpr auto N = glz::tuple_size_v; 230| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 231| | 232| | using Params = glz::tuple_element_t<0, Tuple>; 233| | 234| | impl::template register_param_function_endpoint(full_key, func, *this); 235| | } 236| | else if constexpr (std::is_pointer_v> && 237| | (glaze_object_t>> || 238| | reflectable>>)) { 239| | // Handle pointer members explicitly for RPC traversal 240| | if (func) { // Only traverse if pointer is valid 241| | on>, full_key>(*func); 242| | impl::template register_object_endpoint>>( 243| | full_key, *func, *this); 244| | } 245| | // else: skip registration for null pointers - no endpoints created 246| | } 247| | else if constexpr (glaze_object_t> || reflectable>) { 248| | on, full_key>(func); 249| | 250| | impl::template register_object_endpoint>(full_key, func, *this); 251| | } 252| | else if constexpr (not std::is_lvalue_reference_v) { 253| | // For glz::custom, glz::manage, etc. 254| | impl::template register_value_endpoint>(full_key, func, *this); 255| | } 256| | else { 257| | static_assert(std::is_lvalue_reference_v); 258| | 259| | if constexpr (std::is_member_function_pointer_v>) { 260| | using F = std::decay_t; 261| | using Ret = typename return_type::type; 262| | using Tuple = typename inputs_as_tuple::type; 263| | constexpr auto n_args = glz::tuple_size_v; 264| | if constexpr (std::is_void_v) { 265| | if constexpr (n_args == 0) { 266| | impl::template register_member_function_endpoint(full_key, value, func, *this); 267| | } 268| | else if constexpr (n_args == 1) { 269| | using Input = std::decay_t>; 270| | impl::template register_member_function_with_params_endpoint(full_key, value, 271| | func, *this); 272| | } 273| | else { 274| | static_assert(false_v, "function cannot have more than one input"); 275| | } 276| | } 277| | else { 278| | // Member function pointers 279| | if constexpr (n_args == 0) { 280| | impl::template register_member_function_endpoint(full_key, value, func, *this); 281| | } 282| | else if constexpr (n_args == 1) { 283| | using Input = std::decay_t>; 284| | impl::template register_member_function_with_params_endpoint(full_key, value, 285| | func, *this); 286| | } 287| | else { 288| | static_assert(false_v, "function cannot have more than one input"); 289| | } 290| | } 291| | } 292| | else { 293| | // this is a variable and not a function, so we build RPC read/write calls 294| | // We can't remove const here, because const fields need to be able to be written 295| | impl::template register_variable_endpoint>(full_key, func, *this); 296| | } 297| | } 298| 66.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDavENKUlvE_clEv: 191| 66.7k| decltype(auto) func = [&]() -> decltype(auto) { 192| 66.7k| if constexpr (reflectable) { 193| 66.7k| return get_member(value, get(t)); 194| | } 195| | else { 196| | return get_member(value, get(reflect::values)); 197| | } 198| 66.7k| }(); _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE: 513| 66.7k| { 514| | // Find first non-whitespace to determine batch vs single request 515| 66.7k| auto it = std::find_if(json_request.begin(), json_request.end(), 516| 66.7k| [](char c) { return !std::isspace(static_cast(c)); }); 517| | 518| 66.7k| if (it != json_request.end() && *it == '[') { ------------------ | Branch (518:14): [True: 66.7k, False: 16] | Branch (518:42): [True: 25.3k, False: 41.3k] ------------------ 519| | // Batch request 520| 25.3k| std::vector batch_requests{}; 521| 25.3k| if (const auto ec = glz::read(batch_requests, json_request); ec) { ------------------ | Branch (521:85): [True: 7.27k, False: 18.1k] ------------------ 522| 7.27k| return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" + 523| 7.27k| write_json(format_error(ec, json_request)).value_or("null") + R"(},"id":null})"; 524| 7.27k| } 525| 18.1k| if (batch_requests.empty()) { ------------------ | Branch (525:17): [True: 13, False: 18.0k] ------------------ 526| 13| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":"Empty batch"},"id":null})"; 527| 13| } 528| 18.0k| return process_batch(batch_requests); 529| 18.1k| } 530| | 531| | // Single request 532| 41.3k| auto response = process_single_request(json_request); 533| 41.3k| return response.value_or(""); 534| 66.7k| } _ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlcE_clEc: 516| 71.6k| [](char c) { return !std::isspace(static_cast(c)); }); _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE13process_batchERKNSt3__16vectorINS_14basic_raw_jsonINS3_17basic_string_viewIcNS3_11char_traitsIcEEEEEENS3_9allocatorISA_EEEEQeqT0_L_ZNS_7JSONRPCEE: 644| 18.0k| { 645| 18.0k| std::vector responses; 646| 18.0k| responses.reserve(batch.size()); 647| | 648| 18.0k| size_t total_size = 2; // [] 649| 4.42M| for (const auto& req : batch) { ------------------ | Branch (649:31): [True: 4.42M, False: 18.0k] ------------------ 650| 4.42M| auto response = process_single_request(req.str); 651| 4.42M| if (response.has_value()) { ------------------ | Branch (651:17): [True: 4.40M, False: 17.4k] ------------------ 652| 4.40M| total_size += response->size() + 1; // +1 for comma 653| | // Checked as the batch is walked rather than after it, so the elements past the 654| | // limit are never run and what they would have answered with is never built. The 655| | // element that trips it has already been built, so the peak is the limit plus one 656| | // response rather than the limit exactly. The elements already run keep their 657| | // effects -- a JSON RPC batch is not a transaction -- but the caller is told the 658| | // batch failed rather than handed a partial array it cannot distinguish from a 659| | // complete one. 660| 4.40M| if (total_size > max_batch_response_size) { ------------------ | Branch (660:20): [True: 7, False: 4.40M] ------------------ 661| 7| return R"({"jsonrpc":"2.0","error":{"code":-32000,"message":"Server error","data":"Batch response exceeds max_batch_response_size"},"id":null})"; 662| 7| } 663| 4.40M| responses.push_back(std::move(*response)); 664| 4.40M| } 665| 4.42M| } 666| | 667| | // If all were notifications, return empty string 668| 18.0k| if (responses.empty()) { ------------------ | Branch (668:14): [True: 190, False: 17.8k] ------------------ 669| 190| return ""; 670| 190| } 671| | 672| | // Build batch response array with pre-reserved capacity 673| 17.8k| std::string result; 674| 17.8k| result.reserve(total_size); 675| 17.8k| result = "["; 676| 3.34M| for (size_t i = 0; i < responses.size(); ++i) { ------------------ | Branch (676:29): [True: 3.32M, False: 17.8k] ------------------ 677| 3.32M| if (i > 0) { ------------------ | Branch (677:17): [True: 3.30M, False: 17.8k] ------------------ 678| 3.30M| result += ","; 679| 3.30M| } 680| 3.32M| result += responses[i]; 681| 3.32M| } 682| 17.8k| result += "]"; 683| 17.8k| return result; 684| 18.0k| } _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE: 540| 4.46M| { 541| 4.46M| rpc::request_envelope_t request{}; 542| 4.46M| if (const auto read_ec = glz::read(request, json_request); read_ec) { ------------------ | Branch (542:80): [True: 4.40M, False: 62.1k] ------------------ 543| | // Check if it's a JSON syntax error vs schema error 544| 4.40M| static constexpr registry_validate_opts validate_opts{{read_opts}}; 545| 4.40M| glz::skip skip_value{}; 546| 4.40M| context validate_ctx{}; 547| 4.40M| if (glz::read(skip_value, json_request, validate_ctx)) { ------------------ | Branch (547:17): [True: 4.29M, False: 112k] ------------------ 548| | // JSON is syntactically invalid - return Parse error (-32700) 549| 4.29M| return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" + 550| 4.29M| write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":null})"; 551| 4.29M| } 552| | // Valid JSON but invalid request structure - return Invalid Request (-32600) 553| 112k| auto id = glz::get_as_json(json_request); 554| 112k| std::string id_json = id.has_value() ? glz::write_json(id.value()).value_or("null") : "null"; ------------------ | Branch (554:35): [True: 3.19k, False: 108k] ------------------ 555| 112k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 556| 112k| write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":)" + id_json + "}"; 557| 4.40M| } 558| | 559| 62.1k| auto& req = request; 560| | 561| 62.1k| const auto invalid_request = [&req](const std::string& data) { 562| 62.1k| std::string id_json = glz::write_json(req.id).value_or("null"); 563| 62.1k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 564| 62.1k| write_json(data).value_or("null") + R"(},"id":)" + id_json + "}"; 565| 62.1k| }; 566| | 567| | // `jsonrpc` and `method` are both required members, and an absent one cannot be allowed to 568| | // fall through to a default: an absent version would pass for 2.0, and an absent method 569| | // names "", which is the root endpoint -- so `{"id":1}` would answer with the whole 570| | // registered object rather than being rejected. 571| 62.1k| if (!req.version) { ------------------ | Branch (571:14): [True: 13.5k, False: 48.6k] ------------------ 572| 13.5k| return invalid_request("Missing 'jsonrpc' member"); 573| 13.5k| } 574| 48.6k| if (*req.version != rpc::supported_version) { ------------------ | Branch (574:14): [True: 4.75k, False: 43.8k] ------------------ 575| 4.75k| return invalid_request("Invalid version: " + std::string(*req.version)); 576| 4.75k| } 577| 43.8k| if (!req.method) { ------------------ | Branch (577:14): [True: 274, False: 43.5k] ------------------ 578| 274| return invalid_request("Missing 'method' member"); 579| 274| } 580| 43.5k| const std::string_view method_name = *req.method; 581| | 582| | // Check if this is a notification (id is null) 583| 43.5k| bool is_notification = std::holds_alternative(req.id); 584| | 585| | // Look up the endpoint - try direct lookup first (handles methods that already start with /) 586| 43.5k| auto it = endpoints.find(method_name); 587| 43.5k| if (it == endpoints.end()) { ------------------ | Branch (587:14): [True: 32.3k, False: 11.2k] ------------------ 588| 32.3k| if (!method_name.empty()) { ------------------ | Branch (588:17): [True: 32.3k, False: 0] ------------------ 589| | // Try with leading slash using stack buffer for common case 590| 32.3k| char buf[256]; 591| 32.3k| if (method_name.size() < sizeof(buf) - 1) { ------------------ | Branch (591:20): [True: 32.3k, False: 0] ------------------ 592| 32.3k| buf[0] = '/'; 593| 32.3k| std::memcpy(buf + 1, method_name.data(), method_name.size()); 594| 32.3k| it = endpoints.find(std::string_view{buf, method_name.size() + 1}); 595| 32.3k| } 596| 0| else { 597| | // Fallback for very long method names 598| 0| std::string method_path = "/"; 599| 0| method_path += method_name; 600| 0| it = endpoints.find(method_path); 601| 0| } 602| 32.3k| } 603| 0| else { 604| | // Empty method - try root endpoint 605| 0| it = endpoints.find(""); 606| 0| } 607| 32.3k| if (it == endpoints.end()) { ------------------ | Branch (607:17): [True: 108, False: 32.2k] ------------------ 608| 108| if (is_notification) { ------------------ | Branch (608:20): [True: 71, False: 37] ------------------ 609| 71| return std::nullopt; // No response for notifications 610| 71| } 611| 37| std::string id_json = glz::write_json(req.id).value_or("null"); 612| 37| return R"({"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found","data":)" + 613| 37| write_json(method_name).value_or("null") + R"(},"id":)" + id_json + "}"; 614| 108| } 615| 32.3k| } 616| | 617| | // Prepare state 618| 43.4k| std::string response; 619| 43.4k| bool has_params = !req.params.str.empty() && req.params.str != "null"; ------------------ | Branch (619:28): [True: 25.0k, False: 18.4k] | Branch (619:55): [True: 25.0k, False: 5] ------------------ 620| 43.4k| jsonrpc::state state{req.id, response, is_notification, has_params, req.params.str}; 621| | 622| 43.4k| try { 623| 43.4k| it->second(std::move(state)); 624| 43.4k| } 625| 43.4k| catch (const std::exception& e) { 626| 0| if (is_notification) { ------------------ | Branch (626:17): [True: 0, False: 0] ------------------ 627| 0| return std::nullopt; 628| 0| } 629| 0| std::string id_json = glz::write_json(req.id).value_or("null"); 630| 0| return R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":)" + 631| 0| write_json(std::string_view{e.what()}).value_or("null") + R"(},"id":)" + id_json + "}"; 632| 0| } 633| | 634| 43.4k| if (is_notification) { ------------------ | Branch (634:14): [True: 20.8k, False: 22.6k] ------------------ 635| 20.8k| return std::nullopt; 636| 20.8k| } 637| | 638| 22.6k| return response; 639| 43.4k| } _ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlRKNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEE_clESD_: 561| 18.5k| const auto invalid_request = [&req](const std::string& data) { 562| 18.5k| std::string id_json = glz::write_json(req.id).value_or("null"); 563| 18.5k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 564| 18.5k| write_json(data).value_or("null") + R"(},"id":)" + id_json + "}"; 565| 18.5k| }; _ZNK3glz6detail11string_hashclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 27| 1.61M| [[nodiscard]] size_t operator()(std::string_view txt) const { return std::hash{}(txt); } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS9_RKS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcST_RPT_mSN_: 17| 47.1k| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 47.1k| if (n > 15) { ------------------ | Branch (19:11): [True: 32.8k, False: 14.3k] ------------------ 20| 32.8k| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 32.8k| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 32.8k| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 32.8k| const __m128i zero = _mm_setzero_si128(); 24| | 25| 13.3M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 13.3M, False: 32.8k] ------------------ 26| 13.3M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 13.3M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 13.3M| const uint32_t mask = static_cast( 30| 13.3M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 13.3M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 13.3M| if (mask == 0) { ------------------ | Branch (33:17): [True: 109k, False: 13.1M] ------------------ 34| 109k| data += 16; 35| 109k| c += 16; 36| 109k| continue; 37| 109k| } 38| | 39| 13.1M| const uint32_t length = countr_zero(mask); 40| 13.1M| c += length; 41| 13.1M| data += length; 42| 13.1M| write_escape(); 43| 13.1M| } 44| 32.8k| } 45| 47.1k| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSU_RPT_mSO_: 17| 5.38k| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 5.38k| if (n > 15) { ------------------ | Branch (19:11): [True: 2.91k, False: 2.47k] ------------------ 20| 2.91k| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 2.91k| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 2.91k| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 2.91k| const __m128i zero = _mm_setzero_si128(); 24| | 25| 28.6M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 28.6M, False: 2.91k] ------------------ 26| 28.6M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 28.6M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 28.6M| const uint32_t mask = static_cast( 30| 28.6M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 28.6M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 28.6M| if (mask == 0) { ------------------ | Branch (33:17): [True: 556k, False: 28.0M] ------------------ 34| 556k| data += 16; 35| 556k| c += 16; 36| 556k| continue; 37| 556k| } 38| | 39| 28.0M| const uint32_t length = countr_zero(mask); 40| 28.0M| c += length; 41| 28.0M| data += length; 42| 28.0M| write_escape(); 43| 28.0M| } 44| 2.91k| } 45| 5.38k| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS9_SD_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 17| 950| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 950| if (n > 15) { ------------------ | Branch (19:11): [True: 248, False: 702] ------------------ 20| 248| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 248| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 248| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 248| const __m128i zero = _mm_setzero_si128(); 24| | 25| 1.01M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 1.01M, False: 248] ------------------ 26| 1.01M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 1.01M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 1.01M| const uint32_t mask = static_cast( 30| 1.01M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 1.01M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 1.01M| if (mask == 0) { ------------------ | Branch (33:17): [True: 1.00M, False: 5.90k] ------------------ 34| 1.00M| data += 16; 35| 1.00M| c += 16; 36| 1.00M| continue; 37| 1.00M| } 38| | 39| 5.90k| const uint32_t length = countr_zero(mask); 40| 5.90k| c += length; 41| 5.90k| data += length; 42| 5.90k| write_escape(); 43| 5.90k| } 44| 248| } 45| 950| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS9_S9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 17| 4.41M| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 4.41M| if (n > 15) { ------------------ | Branch (19:11): [True: 4.41M, False: 0] ------------------ 20| 4.41M| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 4.41M| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 4.41M| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 4.41M| const __m128i zero = _mm_setzero_si128(); 24| | 25| 9.75M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 5.34M, False: 4.41M] ------------------ 26| 5.34M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 5.34M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 5.34M| const uint32_t mask = static_cast( 30| 5.34M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 5.34M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 5.34M| if (mask == 0) { ------------------ | Branch (33:17): [True: 4.53M, False: 802k] ------------------ 34| 4.53M| data += 16; 35| 4.53M| c += 16; 36| 4.53M| continue; 37| 4.53M| } 38| | 39| 802k| const uint32_t length = countr_zero(mask); 40| 802k| c += length; 41| 802k| data += length; 42| 802k| write_escape(); 43| 802k| } 44| 4.41M| } 45| 4.41M| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS3_12basic_stringIcS6_NS3_9allocatorIcEEEERKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSV_RPT_mSP_: 17| 37| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 37| if (n > 15) { ------------------ | Branch (19:11): [True: 0, False: 37] ------------------ 20| 0| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 0| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 0| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 0| const __m128i zero = _mm_setzero_si128(); 24| | 25| 0| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 0, False: 0] ------------------ 26| 0| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 0| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 0| const uint32_t mask = static_cast( 30| 0| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 0| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 0| if (mask == 0) { ------------------ | Branch (33:17): [True: 0, False: 0] ------------------ 34| 0| data += 16; 35| 0| c += 16; 36| 0| continue; 37| 0| } 38| | 39| 0| const uint32_t length = countr_zero(mask); 40| 0| c += length; 41| 0| data += length; 42| 0| write_escape(); 43| 0| } 44| 0| } 45| 37| } _ZN3glz4atoiITkNSt3__18integralEicEEbRT_RPKT0_S6_: 803| 857k| { 804| | // The number of characters needed at most for each type, rounded to nearest 8 bytes 805| 857k| constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1]; 806| | // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The 807| | // trailing byte is never written by the copy, so the null-terminated atoi below always halts 808| | // inside the array even when the input fills it: the exponent scan stops at a non-digit rather 809| | // than after a fixed digit count, and a value-initialized array alone would not terminate a 810| | // copy that covers every byte. 811| 857k| std::array data{}; 812| 857k| const auto n = size_t(end - it); 813| 857k| if (n > 0) [[likely]] { ------------------ | Branch (813:11): [True: 857k, False: 0] ------------------ 814| 857k| const auto truncated = n > buffer_length; 815| 857k| std::memcpy(data.data(), it, truncated ? buffer_length : n); ------------------ | Branch (815:39): [True: 842k, False: 15.5k] ------------------ 816| | 817| 857k| const auto start = data.data(); 818| 857k| const auto* c = start; 819| 857k| const auto valid = glz::atoi(v, c); 820| 857k| const auto consumed = size_t(c - start); 821| 857k| it += consumed; 822| | // Reaching the end of a truncated copy means the number was cut off: parsing halted on the 823| | // terminator this buffer supplies rather than on a character of the input, so what parsed is 824| | // a prefix and its value is not the number's. Only zero padding can stretch a number this 825| | // far -- no in-range integer needs buffer_length characters -- but a caller that ignores 826| | // trailing content would otherwise take the prefix's value as the answer. 827| 857k| return valid && not(truncated && consumed == buffer_length); ------------------ | Branch (827:17): [True: 853k, False: 4.66k] | Branch (827:30): [True: 841k, False: 11.6k] | Branch (827:43): [True: 3, False: 841k] ------------------ 828| 857k| } 829| 0| else [[unlikely]] { 830| 0| return false; 831| 0| } 832| 857k| } _ZN3glz4atoiITkNSt3__18integralEiKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_: 715| 857k| { 716| 857k| using X = std::decay_t; 717| 857k| using utype = std::make_unsigned_t; 718| | 719| 857k| const uint8_t sign = *c == '-'; 720| 857k| if (auto ptr = parse_int(v, reinterpret_cast(c))) [[likely]] { ------------------ | Branch (720:16): [True: 855k, False: 2.83k] ------------------ 721| 855k| c = reinterpret_cast(ptr); 722| 855k| if (*c == 'e' || *c == 'E') { ------------------ | Branch (722:14): [True: 15.5k, False: 839k] | Branch (722:27): [True: 26.7k, False: 812k] ------------------ 723| 42.3k| ++c; 724| 42.3k| } 725| 812k| else { 726| 812k| if (*c == '.') [[unlikely]] { ------------------ | Branch (726:17): [True: 47, False: 812k] ------------------ 727| 47| return false; 728| 47| } 729| 812k| return true; 730| 812k| } 731| | 732| 42.3k| c += (*c == '+'); 733| | 734| 42.3k| if (not is_digit(*c)) [[unlikely]] { ------------------ | Branch (734:14): [True: 341, False: 41.9k] ------------------ 735| 341| return false; 736| 341| } 737| 41.9k| const uint32_t exp = parse_exponent(c); 738| | // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and 739| | // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative 740| | // zero compares equal to zero, so both spellings land here with the value they should keep. 741| | if constexpr (sizeof(T) == 1) { 742| | if (exp > 2) [[unlikely]] { 743| | return v == 0; 744| | } 745| | } 746| | else if constexpr (sizeof(T) == 2) { 747| | if (exp > 4) [[unlikely]] { 748| | return v == 0; 749| | } 750| | } 751| 41.9k| else if constexpr (sizeof(T) == 4) { 752| 41.9k| if (exp > 9) [[unlikely]] { ------------------ | Branch (752:17): [True: 4.60k, False: 37.3k] ------------------ 753| 4.60k| return v == 0; 754| 4.60k| } 755| | } 756| | else { 757| | if (exp > 18) [[unlikely]] { 758| | return v == 0; 759| | } 760| | } 761| | 762| 37.3k| utype i = utype((utype(v) ^ -sign) + sign); 763| 41.9k| if constexpr (sizeof(T) < 8) { 764| | // Scale in a width the product cannot wrap, then range check before narrowing. Scaling 765| | // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude 766| | // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for 767| | // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well 768| | // inside uint64_t. The unsigned path already widens the same way. 769| 41.9k| const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp]; 770| 41.9k| v = T((utype(scaled) ^ -sign) + sign); 771| | // Bound the magnitude directly rather than subtracting the sign from it: a negative 772| | // zero makes `scaled - sign` underflow, and the old narrow expression only survived 773| | // that because it promoted to int. A negative value may reach one past the positive 774| | // limit, which is exactly INT_MIN's magnitude. 775| 41.9k| return scaled <= uint64_t((std::numeric_limits::max)()) + sign; 776| | } 777| | else { 778| | // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`: 779| | // for a negative value that pattern is a huge unsigned number, so every negative 780| | // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The 781| | // narrower branches above already scale `i`. 782| |#if defined(__SIZEOF_INT128__) 783| | const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp]; 784| | v = T((uint64_t(res) ^ -sign) + sign); 785| | // Compare the full 128-bit product. Narrowing it to 64 bits first would let an 786| | // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range. 787| | return res <= __uint128_t(9223372036854775807ull + sign); 788| |#else 789| | const auto res = full_multiplication(i, powers_of_ten_int[exp]); 790| | v = T((uint64_t(res.low) ^ -sign) + sign); 791| | return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign)); 792| |#endif 793| | } 794| 41.9k| } 795| 44.7k| return false; 796| 857k| } _ZN3glz9parse_intITkNSt3__18integralEiQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_: 476| 857k| { 477| 857k| const uint8_t sign = *c == '-'; 478| 857k| c += sign; 479| | 480| 857k| if (is_digit(*c)) [[likely]] { ------------------ | Branch (480:11): [True: 855k, False: 2.40k] ------------------ 481| 855k| v = *c - '0'; 482| 855k| ++c; 483| 855k| } 484| 2.40k| else [[unlikely]] { 485| 2.40k| return {}; 486| 2.40k| } 487| | 488| 855k| if (is_digit(*c)) { ------------------ | Branch (488:11): [True: 708k, False: 147k] ------------------ 489| 708k| v = v * 10 + (*c - '0'); 490| 708k| ++c; 491| 708k| } 492| 147k| else { 493| 147k| if (sign) { ------------------ | Branch (493:14): [True: 87.7k, False: 59.4k] ------------------ 494| 87.7k| v = -v; 495| 87.7k| } 496| 147k| return c; 497| 147k| } 498| | 499| 708k| if (c[-2] == '0') [[unlikely]] { ------------------ | Branch (499:11): [True: 72, False: 708k] ------------------ 500| 72| return {}; 501| 72| } 502| | 503| 708k| if constexpr (sizeof(T) > 1) { 504| 708k| if (is_digit(*c)) { ------------------ | Branch (504:14): [True: 388k, False: 319k] ------------------ 505| 388k| v = v * 10 + (*c - '0'); 506| 388k| ++c; 507| 388k| } 508| 319k| else { 509| 319k| if (sign) { ------------------ | Branch (509:17): [True: 272k, False: 46.4k] ------------------ 510| 272k| v = -v; 511| 272k| } 512| 319k| return c; 513| 319k| } 514| | 515| 388k| if (is_digit(*c)) { ------------------ | Branch (515:14): [True: 200k, False: 188k] ------------------ 516| 200k| v = v * 10 + (*c - '0'); 517| 200k| ++c; 518| 200k| } 519| 188k| else { 520| 188k| if (sign) { ------------------ | Branch (520:17): [True: 167k, False: 20.7k] ------------------ 521| 167k| v = -v; 522| 167k| } 523| 188k| return c; 524| 188k| } 525| | 526| 200k| if constexpr (sizeof(T) > 2) { 527| 200k| if (is_digit(*c)) { ------------------ | Branch (527:17): [True: 125k, False: 74.8k] ------------------ 528| 125k| v = v * 10 + (*c - '0'); 529| 125k| ++c; 530| 125k| } 531| 74.8k| else { 532| 74.8k| if (sign) { ------------------ | Branch (532:20): [True: 7.05k, False: 67.7k] ------------------ 533| 7.05k| v = -v; 534| 7.05k| } 535| 74.8k| return c; 536| 74.8k| } 537| | 538| 125k| if (is_digit(*c)) { ------------------ | Branch (538:17): [True: 106k, False: 19.1k] ------------------ 539| 106k| v = v * 10 + (*c - '0'); 540| 106k| ++c; 541| 106k| } 542| 19.1k| else { 543| 19.1k| if (sign) { ------------------ | Branch (543:20): [True: 3.75k, False: 15.3k] ------------------ 544| 3.75k| v = -v; 545| 3.75k| } 546| 19.1k| return c; 547| 19.1k| } 548| | 549| 106k| if (is_digit(*c)) { ------------------ | Branch (549:17): [True: 63.2k, False: 43.1k] ------------------ 550| 63.2k| v = v * 10 + (*c - '0'); 551| 63.2k| ++c; 552| 63.2k| } 553| 43.1k| else { 554| 43.1k| if (sign) { ------------------ | Branch (554:20): [True: 8.44k, False: 34.7k] ------------------ 555| 8.44k| v = -v; 556| 8.44k| } 557| 43.1k| return c; 558| 43.1k| } 559| | 560| 63.2k| if (is_digit(*c)) { ------------------ | Branch (560:17): [True: 43.9k, False: 19.2k] ------------------ 561| 43.9k| v = v * 10 + (*c - '0'); 562| 43.9k| ++c; 563| 43.9k| } 564| 19.2k| else { 565| 19.2k| if (sign) { ------------------ | Branch (565:20): [True: 3.53k, False: 15.7k] ------------------ 566| 3.53k| v = -v; 567| 3.53k| } 568| 19.2k| return c; 569| 19.2k| } 570| | 571| 43.9k| if (is_digit(*c)) { ------------------ | Branch (571:17): [True: 24.4k, False: 19.5k] ------------------ 572| 24.4k| v = v * 10 + (*c - '0'); 573| 24.4k| ++c; 574| 24.4k| } 575| 19.5k| else { 576| 19.5k| if (sign) { ------------------ | Branch (576:20): [True: 5.60k, False: 13.9k] ------------------ 577| 5.60k| v = -v; 578| 5.60k| } 579| 19.5k| return c; 580| 19.5k| } 581| | 582| | if constexpr (sizeof(T) > 4) { 583| | if (is_digit(*c)) { 584| | v = v * 10 + (*c - '0'); 585| | ++c; 586| | } 587| | else { 588| | if (sign) { 589| | v = -v; 590| | } 591| | return c; 592| | } 593| | 594| | if (is_digit(*c)) { 595| | v = v * 10 + (*c - '0'); 596| | ++c; 597| | } 598| | else { 599| | if (sign) { 600| | v = -v; 601| | } 602| | return c; 603| | } 604| | 605| | if (is_digit(*c)) { 606| | v = v * 10 + (*c - '0'); 607| | ++c; 608| | } 609| | else { 610| | if (sign) { 611| | v = -v; 612| | } 613| | return c; 614| | } 615| | 616| | if (is_digit(*c)) { 617| | v = v * 10 + (*c - '0'); 618| | ++c; 619| | } 620| | else { 621| | if (sign) { 622| | v = -v; 623| | } 624| | return c; 625| | } 626| | 627| | if (is_digit(*c)) { 628| | v = v * 10 + (*c - '0'); 629| | ++c; 630| | } 631| | else { 632| | if (sign) { 633| | v = -v; 634| | } 635| | return c; 636| | } 637| | 638| | if (is_digit(*c)) { 639| | v = v * 10 + (*c - '0'); 640| | ++c; 641| | } 642| | else { 643| | if (sign) { 644| | v = -v; 645| | } 646| | return c; 647| | } 648| | 649| | if (is_digit(*c)) { 650| | v = v * 10 + (*c - '0'); 651| | ++c; 652| | } 653| | else { 654| | if (sign) { 655| | v = -v; 656| | } 657| | return c; 658| | } 659| | 660| | if (is_digit(*c)) { 661| | v = v * 10 + (*c - '0'); 662| | ++c; 663| | } 664| | else { 665| | if (sign) { 666| | v = -v; 667| | } 668| | return c; 669| | } 670| | 671| | if (is_digit(*c)) { 672| | v = v * 10 + (*c - '0'); 673| | ++c; 674| | } 675| | else { 676| | if (sign) { 677| | v = -v; 678| | } 679| | return c; 680| | } 681| | } 682| 24.4k| } 683| 200k| } 684| | 685| 708k| if (is_digit(*c)) { ------------------ | Branch (685:11): [True: 10.7k, False: 697k] ------------------ 686| 10.7k| if (sign) { ------------------ | Branch (686:14): [True: 6.64k, False: 4.15k] ------------------ 687| 6.64k| if (would_overflow_negative(v, *c)) [[unlikely]] { ------------------ | Branch (687:17): [True: 124, False: 6.51k] ------------------ 688| 124| return {}; 689| 124| } 690| 6.51k| v = -1 * v; 691| 6.51k| v = v * 10 - (*c - '0'); 692| 6.51k| } 693| 4.15k| else { 694| 4.15k| if (would_overflow_positive(v, *c)) [[unlikely]] { ------------------ | Branch (694:17): [True: 126, False: 4.02k] ------------------ 695| 126| return {}; 696| 126| } 697| 4.02k| v = v * 10 + (*c - '0'); 698| 4.02k| } 699| 10.5k| ++c; 700| 10.5k| if (is_digit(*c)) [[unlikely]] { ------------------ | Branch (700:14): [True: 111, False: 10.4k] ------------------ 701| 111| return {}; 702| 111| } 703| 10.4k| return c; 704| 10.5k| } 705| | 706| 697k| if (sign) { ------------------ | Branch (706:11): [True: 4.65k, False: 692k] ------------------ 707| 4.65k| v = -v; 708| 4.65k| } 709| 697k| return c; 710| 708k| } _ZN3glz23would_overflow_negativeIiEEbu17__remove_volatileIT_Eh: 151| 6.64k| { 152| | // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32) 153| 6.64k| using U = std::remove_volatile_t; 154| 6.64k| constexpr auto max_val = static_cast((std::numeric_limits::max)()) + 1; 155| 6.64k| constexpr auto threshold = max_val / 10; 156| 6.64k| constexpr auto last_digit = max_val % 10; 157| 6.64k| const auto uv = static_cast(v); 158| 6.64k| const auto digit = static_cast(next_digit - '0'); 159| | // When digit > last_digit, effective threshold is one less 160| 6.64k| return uv > (threshold - uint64_t(digit > last_digit)); 161| 6.64k| } _ZN3glz23would_overflow_positiveIiEEbu17__remove_volatileIT_Eh: 137| 4.15k| { 138| 4.15k| using U = std::remove_volatile_t; 139| 4.15k| constexpr auto max_val = static_cast((std::numeric_limits::max)()); 140| 4.15k| constexpr auto threshold = max_val / 10; 141| 4.15k| constexpr auto last_digit = max_val % 10; 142| 4.15k| const auto uv = static_cast(v); 143| 4.15k| const auto digit = static_cast(next_digit - '0'); 144| | // When digit > last_digit, effective threshold is one less 145| | // This is branch-free and faster than bitwise OR/AND approach 146| 4.15k| return uv > (threshold - uint64_t(digit > last_digit)); 147| 4.15k| } _ZN3glz8is_digitEh: 103| 13.7M| GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; } ------------------ | Branch (103:81): [True: 13.3M, False: 437k] | Branch (103:93): [True: 7.37M, False: 5.97M] ------------------ _ZN3glz14parse_exponentIKcEEjRPT_: 121| 49.8k| { 122| 49.8k| uint32_t exp = uint32_t(*c - '0'); 123| 49.8k| ++c; 124| 116k| while (is_digit(*c)) { ------------------ | Branch (124:14): [True: 66.7k, False: 49.8k] ------------------ 125| | // Written as a select rather than a branch: the clamp only ever engages on absurdly long 126| | // exponents, so a branch here would be a mispredict risk on the path that matters. 127| 66.7k| exp = exp < exponent_clamp ? exp * 10 + uint32_t(*c - '0') : exp; ------------------ | Branch (127:16): [True: 60.3k, False: 6.33k] ------------------ 128| 66.7k| ++c; 129| 66.7k| } 130| 49.8k| return exp; 131| 49.8k| } _ZN3glz4atoiITkNSt3__18integralElcEEbRT_RPKT0_S6_: 803| 72.3k| { 804| | // The number of characters needed at most for each type, rounded to nearest 8 bytes 805| 72.3k| constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1]; 806| | // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The 807| | // trailing byte is never written by the copy, so the null-terminated atoi below always halts 808| | // inside the array even when the input fills it: the exponent scan stops at a non-digit rather 809| | // than after a fixed digit count, and a value-initialized array alone would not terminate a 810| | // copy that covers every byte. 811| 72.3k| std::array data{}; 812| 72.3k| const auto n = size_t(end - it); 813| 72.3k| if (n > 0) [[likely]] { ------------------ | Branch (813:11): [True: 72.3k, False: 0] ------------------ 814| 72.3k| const auto truncated = n > buffer_length; 815| 72.3k| std::memcpy(data.data(), it, truncated ? buffer_length : n); ------------------ | Branch (815:39): [True: 19.5k, False: 52.7k] ------------------ 816| | 817| 72.3k| const auto start = data.data(); 818| 72.3k| const auto* c = start; 819| 72.3k| const auto valid = glz::atoi(v, c); 820| 72.3k| const auto consumed = size_t(c - start); 821| 72.3k| it += consumed; 822| | // Reaching the end of a truncated copy means the number was cut off: parsing halted on the 823| | // terminator this buffer supplies rather than on a character of the input, so what parsed is 824| | // a prefix and its value is not the number's. Only zero padding can stretch a number this 825| | // far -- no in-range integer needs buffer_length characters -- but a caller that ignores 826| | // trailing content would otherwise take the prefix's value as the answer. 827| 72.3k| return valid && not(truncated && consumed == buffer_length); ------------------ | Branch (827:17): [True: 54.5k, False: 17.8k] | Branch (827:30): [True: 18.4k, False: 36.0k] | Branch (827:43): [True: 84, False: 18.3k] ------------------ 828| 72.3k| } 829| 0| else [[unlikely]] { 830| 0| return false; 831| 0| } 832| 72.3k| } _ZN3glz4atoiITkNSt3__18integralElKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_: 715| 72.3k| { 716| 72.3k| using X = std::decay_t; 717| 72.3k| using utype = std::make_unsigned_t; 718| | 719| 72.3k| const uint8_t sign = *c == '-'; 720| 72.3k| if (auto ptr = parse_int(v, reinterpret_cast(c))) [[likely]] { ------------------ | Branch (720:16): [True: 62.9k, False: 9.35k] ------------------ 721| 62.9k| c = reinterpret_cast(ptr); 722| 62.9k| if (*c == 'e' || *c == 'E') { ------------------ | Branch (722:14): [True: 2.40k, False: 60.5k] | Branch (722:27): [True: 6.65k, False: 53.9k] ------------------ 723| 9.05k| ++c; 724| 9.05k| } 725| 53.9k| else { 726| 53.9k| if (*c == '.') [[unlikely]] { ------------------ | Branch (726:17): [True: 2.68k, False: 51.2k] ------------------ 727| 2.68k| return false; 728| 2.68k| } 729| 51.2k| return true; 730| 53.9k| } 731| | 732| 9.05k| c += (*c == '+'); 733| | 734| 9.05k| if (not is_digit(*c)) [[unlikely]] { ------------------ | Branch (734:14): [True: 1.17k, False: 7.87k] ------------------ 735| 1.17k| return false; 736| 1.17k| } 737| 7.87k| const uint32_t exp = parse_exponent(c); 738| | // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and 739| | // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative 740| | // zero compares equal to zero, so both spellings land here with the value they should keep. 741| | if constexpr (sizeof(T) == 1) { 742| | if (exp > 2) [[unlikely]] { 743| | return v == 0; 744| | } 745| | } 746| | else if constexpr (sizeof(T) == 2) { 747| | if (exp > 4) [[unlikely]] { 748| | return v == 0; 749| | } 750| | } 751| | else if constexpr (sizeof(T) == 4) { 752| | if (exp > 9) [[unlikely]] { 753| | return v == 0; 754| | } 755| | } 756| 7.87k| else { 757| 7.87k| if (exp > 18) [[unlikely]] { ------------------ | Branch (757:17): [True: 4.48k, False: 3.39k] ------------------ 758| 4.48k| return v == 0; 759| 4.48k| } 760| 7.87k| } 761| | 762| 3.39k| utype i = utype((utype(v) ^ -sign) + sign); 763| | if constexpr (sizeof(T) < 8) { 764| | // Scale in a width the product cannot wrap, then range check before narrowing. Scaling 765| | // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude 766| | // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for 767| | // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well 768| | // inside uint64_t. The unsigned path already widens the same way. 769| | const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp]; 770| | v = T((utype(scaled) ^ -sign) + sign); 771| | // Bound the magnitude directly rather than subtracting the sign from it: a negative 772| | // zero makes `scaled - sign` underflow, and the old narrow expression only survived 773| | // that because it promoted to int. A negative value may reach one past the positive 774| | // limit, which is exactly INT_MIN's magnitude. 775| | return scaled <= uint64_t((std::numeric_limits::max)()) + sign; 776| | } 777| 7.87k| else { 778| | // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`: 779| | // for a negative value that pattern is a huge unsigned number, so every negative 780| | // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The 781| | // narrower branches above already scale `i`. 782| 7.87k|#if defined(__SIZEOF_INT128__) 783| 7.87k| const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp]; 784| 7.87k| v = T((uint64_t(res) ^ -sign) + sign); 785| | // Compare the full 128-bit product. Narrowing it to 64 bits first would let an 786| | // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range. 787| 7.87k| return res <= __uint128_t(9223372036854775807ull + sign); 788| |#else 789| | const auto res = full_multiplication(i, powers_of_ten_int[exp]); 790| | v = T((uint64_t(res.low) ^ -sign) + sign); 791| | return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign)); 792| |#endif 793| 7.87k| } 794| 7.87k| } 795| 17.2k| return false; 796| 72.3k| } _ZN3glz9parse_intITkNSt3__18integralElQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_: 476| 72.3k| { 477| 72.3k| const uint8_t sign = *c == '-'; 478| 72.3k| c += sign; 479| | 480| 72.3k| if (is_digit(*c)) [[likely]] { ------------------ | Branch (480:11): [True: 70.9k, False: 1.39k] ------------------ 481| 70.9k| v = *c - '0'; 482| 70.9k| ++c; 483| 70.9k| } 484| 1.39k| else [[unlikely]] { 485| 1.39k| return {}; 486| 1.39k| } 487| | 488| 70.9k| if (is_digit(*c)) { ------------------ | Branch (488:11): [True: 39.7k, False: 31.2k] ------------------ 489| 39.7k| v = v * 10 + (*c - '0'); 490| 39.7k| ++c; 491| 39.7k| } 492| 31.2k| else { 493| 31.2k| if (sign) { ------------------ | Branch (493:14): [True: 1.87k, False: 29.3k] ------------------ 494| 1.87k| v = -v; 495| 1.87k| } 496| 31.2k| return c; 497| 31.2k| } 498| | 499| 39.7k| if (c[-2] == '0') [[unlikely]] { ------------------ | Branch (499:11): [True: 392, False: 39.3k] ------------------ 500| 392| return {}; 501| 392| } 502| | 503| 39.3k| if constexpr (sizeof(T) > 1) { 504| 39.3k| if (is_digit(*c)) { ------------------ | Branch (504:14): [True: 37.4k, False: 1.86k] ------------------ 505| 37.4k| v = v * 10 + (*c - '0'); 506| 37.4k| ++c; 507| 37.4k| } 508| 1.86k| else { 509| 1.86k| if (sign) { ------------------ | Branch (509:17): [True: 761, False: 1.10k] ------------------ 510| 761| v = -v; 511| 761| } 512| 1.86k| return c; 513| 1.86k| } 514| | 515| 37.4k| if (is_digit(*c)) { ------------------ | Branch (515:14): [True: 35.8k, False: 1.55k] ------------------ 516| 35.8k| v = v * 10 + (*c - '0'); 517| 35.8k| ++c; 518| 35.8k| } 519| 1.55k| else { 520| 1.55k| if (sign) { ------------------ | Branch (520:17): [True: 568, False: 986] ------------------ 521| 568| v = -v; 522| 568| } 523| 1.55k| return c; 524| 1.55k| } 525| | 526| 35.8k| if constexpr (sizeof(T) > 2) { 527| 35.8k| if (is_digit(*c)) { ------------------ | Branch (527:17): [True: 33.3k, False: 2.54k] ------------------ 528| 33.3k| v = v * 10 + (*c - '0'); 529| 33.3k| ++c; 530| 33.3k| } 531| 2.54k| else { 532| 2.54k| if (sign) { ------------------ | Branch (532:20): [True: 1.51k, False: 1.03k] ------------------ 533| 1.51k| v = -v; 534| 1.51k| } 535| 2.54k| return c; 536| 2.54k| } 537| | 538| 33.3k| if (is_digit(*c)) { ------------------ | Branch (538:17): [True: 28.0k, False: 5.26k] ------------------ 539| 28.0k| v = v * 10 + (*c - '0'); 540| 28.0k| ++c; 541| 28.0k| } 542| 5.26k| else { 543| 5.26k| if (sign) { ------------------ | Branch (543:20): [True: 4.34k, False: 911] ------------------ 544| 4.34k| v = -v; 545| 4.34k| } 546| 5.26k| return c; 547| 5.26k| } 548| | 549| 28.0k| if (is_digit(*c)) { ------------------ | Branch (549:17): [True: 26.1k, False: 1.96k] ------------------ 550| 26.1k| v = v * 10 + (*c - '0'); 551| 26.1k| ++c; 552| 26.1k| } 553| 1.96k| else { 554| 1.96k| if (sign) { ------------------ | Branch (554:20): [True: 881, False: 1.08k] ------------------ 555| 881| v = -v; 556| 881| } 557| 1.96k| return c; 558| 1.96k| } 559| | 560| 26.1k| if (is_digit(*c)) { ------------------ | Branch (560:17): [True: 24.6k, False: 1.44k] ------------------ 561| 24.6k| v = v * 10 + (*c - '0'); 562| 24.6k| ++c; 563| 24.6k| } 564| 1.44k| else { 565| 1.44k| if (sign) { ------------------ | Branch (565:20): [True: 907, False: 533] ------------------ 566| 907| v = -v; 567| 907| } 568| 1.44k| return c; 569| 1.44k| } 570| | 571| 24.6k| if (is_digit(*c)) { ------------------ | Branch (571:17): [True: 23.1k, False: 1.53k] ------------------ 572| 23.1k| v = v * 10 + (*c - '0'); 573| 23.1k| ++c; 574| 23.1k| } 575| 1.53k| else { 576| 1.53k| if (sign) { ------------------ | Branch (576:20): [True: 893, False: 645] ------------------ 577| 893| v = -v; 578| 893| } 579| 1.53k| return c; 580| 1.53k| } 581| | 582| 23.1k| if constexpr (sizeof(T) > 4) { 583| 23.1k| if (is_digit(*c)) { ------------------ | Branch (583:20): [True: 21.6k, False: 1.51k] ------------------ 584| 21.6k| v = v * 10 + (*c - '0'); 585| 21.6k| ++c; 586| 21.6k| } 587| 1.51k| else { 588| 1.51k| if (sign) { ------------------ | Branch (588:23): [True: 589, False: 930] ------------------ 589| 589| v = -v; 590| 589| } 591| 1.51k| return c; 592| 1.51k| } 593| | 594| 21.6k| if (is_digit(*c)) { ------------------ | Branch (594:20): [True: 20.0k, False: 1.58k] ------------------ 595| 20.0k| v = v * 10 + (*c - '0'); 596| 20.0k| ++c; 597| 20.0k| } 598| 1.58k| else { 599| 1.58k| if (sign) { ------------------ | Branch (599:23): [True: 825, False: 757] ------------------ 600| 825| v = -v; 601| 825| } 602| 1.58k| return c; 603| 1.58k| } 604| | 605| 20.0k| if (is_digit(*c)) { ------------------ | Branch (605:20): [True: 18.8k, False: 1.21k] ------------------ 606| 18.8k| v = v * 10 + (*c - '0'); 607| 18.8k| ++c; 608| 18.8k| } 609| 1.21k| else { 610| 1.21k| if (sign) { ------------------ | Branch (610:23): [True: 604, False: 615] ------------------ 611| 604| v = -v; 612| 604| } 613| 1.21k| return c; 614| 1.21k| } 615| | 616| 18.8k| if (is_digit(*c)) { ------------------ | Branch (616:20): [True: 17.7k, False: 1.10k] ------------------ 617| 17.7k| v = v * 10 + (*c - '0'); 618| 17.7k| ++c; 619| 17.7k| } 620| 1.10k| else { 621| 1.10k| if (sign) { ------------------ | Branch (621:23): [True: 530, False: 575] ------------------ 622| 530| v = -v; 623| 530| } 624| 1.10k| return c; 625| 1.10k| } 626| | 627| 17.7k| if (is_digit(*c)) { ------------------ | Branch (627:20): [True: 16.7k, False: 988] ------------------ 628| 16.7k| v = v * 10 + (*c - '0'); 629| 16.7k| ++c; 630| 16.7k| } 631| 988| else { 632| 988| if (sign) { ------------------ | Branch (632:23): [True: 417, False: 571] ------------------ 633| 417| v = -v; 634| 417| } 635| 988| return c; 636| 988| } 637| | 638| 16.7k| if (is_digit(*c)) { ------------------ | Branch (638:20): [True: 15.6k, False: 1.12k] ------------------ 639| 15.6k| v = v * 10 + (*c - '0'); 640| 15.6k| ++c; 641| 15.6k| } 642| 1.12k| else { 643| 1.12k| if (sign) { ------------------ | Branch (643:23): [True: 598, False: 531] ------------------ 644| 598| v = -v; 645| 598| } 646| 1.12k| return c; 647| 1.12k| } 648| | 649| 15.6k| if (is_digit(*c)) { ------------------ | Branch (649:20): [True: 14.6k, False: 942] ------------------ 650| 14.6k| v = v * 10 + (*c - '0'); 651| 14.6k| ++c; 652| 14.6k| } 653| 942| else { 654| 942| if (sign) { ------------------ | Branch (654:23): [True: 518, False: 424] ------------------ 655| 518| v = -v; 656| 518| } 657| 942| return c; 658| 942| } 659| | 660| 14.6k| if (is_digit(*c)) { ------------------ | Branch (660:20): [True: 13.7k, False: 916] ------------------ 661| 13.7k| v = v * 10 + (*c - '0'); 662| 13.7k| ++c; 663| 13.7k| } 664| 916| else { 665| 916| if (sign) { ------------------ | Branch (665:23): [True: 402, False: 514] ------------------ 666| 402| v = -v; 667| 402| } 668| 916| return c; 669| 916| } 670| | 671| 13.7k| if (is_digit(*c)) { ------------------ | Branch (671:20): [True: 9.53k, False: 4.21k] ------------------ 672| 9.53k| v = v * 10 + (*c - '0'); 673| 9.53k| ++c; 674| 9.53k| } 675| 4.21k| else { 676| 4.21k| if (sign) { ------------------ | Branch (676:23): [True: 3.40k, False: 804] ------------------ 677| 3.40k| v = -v; 678| 3.40k| } 679| 4.21k| return c; 680| 4.21k| } 681| 13.7k| } 682| 23.1k| } 683| 35.8k| } 684| | 685| 39.3k| if (is_digit(*c)) { ------------------ | Branch (685:11): [True: 8.55k, False: 30.7k] ------------------ 686| 8.55k| if (sign) { ------------------ | Branch (686:14): [True: 7.26k, False: 1.28k] ------------------ 687| 7.26k| if (would_overflow_negative(v, *c)) [[unlikely]] { ------------------ | Branch (687:17): [True: 6.56k, False: 696] ------------------ 688| 6.56k| return {}; 689| 6.56k| } 690| 696| v = -1 * v; 691| 696| v = v * 10 - (*c - '0'); 692| 696| } 693| 1.28k| else { 694| 1.28k| if (would_overflow_positive(v, *c)) [[unlikely]] { ------------------ | Branch (694:17): [True: 411, False: 876] ------------------ 695| 411| return {}; 696| 411| } 697| 876| v = v * 10 + (*c - '0'); 698| 876| } 699| 1.57k| ++c; 700| 1.57k| if (is_digit(*c)) [[unlikely]] { ------------------ | Branch (700:14): [True: 593, False: 979] ------------------ 701| 593| return {}; 702| 593| } 703| 979| return c; 704| 1.57k| } 705| | 706| 30.7k| if (sign) { ------------------ | Branch (706:11): [True: 499, False: 30.2k] ------------------ 707| 499| v = -v; 708| 499| } 709| 30.7k| return c; 710| 39.3k| } _ZN3glz23would_overflow_negativeIlEEbu17__remove_volatileIT_Eh: 151| 7.26k| { 152| | // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32) 153| 7.26k| using U = std::remove_volatile_t; 154| 7.26k| constexpr auto max_val = static_cast((std::numeric_limits::max)()) + 1; 155| 7.26k| constexpr auto threshold = max_val / 10; 156| 7.26k| constexpr auto last_digit = max_val % 10; 157| 7.26k| const auto uv = static_cast(v); 158| 7.26k| const auto digit = static_cast(next_digit - '0'); 159| | // When digit > last_digit, effective threshold is one less 160| 7.26k| return uv > (threshold - uint64_t(digit > last_digit)); 161| 7.26k| } _ZN3glz23would_overflow_positiveIlEEbu17__remove_volatileIT_Eh: 137| 1.28k| { 138| 1.28k| using U = std::remove_volatile_t; 139| 1.28k| constexpr auto max_val = static_cast((std::numeric_limits::max)()); 140| 1.28k| constexpr auto threshold = max_val / 10; 141| 1.28k| constexpr auto last_digit = max_val % 10; 142| 1.28k| const auto uv = static_cast(v); 143| 1.28k| const auto digit = static_cast(next_digit - '0'); 144| | // When digit > last_digit, effective threshold is one less 145| | // This is branch-free and faster than bitwise OR/AND approach 146| 1.28k| return uv > (threshold - uint64_t(digit > last_digit)); 147| 1.28k| } _ZN3glz11countr_zeroEm: 29| 10.1M| { 30| |#ifdef _MSC_VER 31| | return std::countr_zero(x); 32| |#else 33| 10.1M|#if __has_builtin(__builtin_ctzll) 34| 10.1M| return __builtin_ctzll(x); 35| |#else 36| | return std::countr_zero(x); 37| |#endif 38| 10.1M|#endif 39| 10.1M| } _ZN3glz11countr_zeroEj: 16| 42.0M| { 17| |#ifdef _MSC_VER 18| | return std::countr_zero(x); 19| |#else 20| 42.0M|#if __has_builtin(__builtin_ctzl) 21| 42.0M| return __builtin_ctzl(x); 22| |#else 23| | return std::countr_zero(x); 24| |#endif 25| 42.0M|#endif 26| 42.0M| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 6.11k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| 6.11k| else if constexpr (N == 2) { 304| 6.11k| static constexpr auto packed = pack(); 305| 6.11k| uint16_t in; 306| 6.11k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 6.11k| return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 6.11k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 1.41k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| 1.41k| else if constexpr (N == 2) { 304| 1.41k| static constexpr auto packed = pack(); 305| 1.41k| uint16_t in; 306| 1.41k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 1.41k| return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.41k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 13.9k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 13.9k| else if constexpr (N == 6) { 268| 13.9k| static constexpr auto packed = pack_buffered(); 269| 13.9k| uint64_t in{}; 270| 13.9k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 13.9k| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 13.9k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm5EcEEbPKT1_: 245| 283| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| 283| else if constexpr (N == 5) { 277| 283| static constexpr auto packed = pack(); 278| 283| uint32_t in; 279| 283| std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| 283| return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 283| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 751| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| 751| else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| 751| return 0 == std::memcmp(Str.data(), other, N); 323| 751| } 324| 751| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 893| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 893| else if constexpr (N == 6) { 268| 893| static constexpr auto packed = pack_buffered(); 269| 893| uint64_t in{}; 270| 893| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 893| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 893| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 12.8k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 12.8k| else if constexpr (N == 6) { 268| 12.8k| static constexpr auto packed = pack_buffered(); 269| 12.8k| uint64_t in{}; 270| 12.8k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 12.8k| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 12.8k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 927| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 927| else if constexpr (N == 6) { 268| 927| static constexpr auto packed = pack_buffered(); 269| 927| uint64_t in{}; 270| 927| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 927| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 927| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 6.94k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| 6.94k| else if constexpr (N == 7) { 259| 6.94k| static constexpr auto packed = pack_buffered(); 260| 6.94k| uint64_t in{}; 261| 6.94k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 6.94k| return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 6.94k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 1.20k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 1.20k| else if constexpr (N == 6) { 268| 1.20k| static constexpr auto packed = pack_buffered(); 269| 1.20k| uint64_t in{}; 270| 1.20k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 1.20k| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.20k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 1.43k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 1.43k| else if constexpr (N == 6) { 268| 1.43k| static constexpr auto packed = pack_buffered(); 269| 1.43k| uint64_t in{}; 270| 1.43k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 1.43k| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.43k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSB_: 245| 1.41k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 1.41k| else if constexpr (N == 3) { 295| 1.41k| static constexpr auto packed = pack(); 296| 1.41k| uint16_t in; 297| 1.41k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 1.41k| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.41k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 1.22k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| 1.22k| if constexpr (N == 8) { 250| 1.22k| static constexpr auto packed = pack(); 251| 1.22k| uint64_t in; 252| 1.22k| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 1.22k| return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.22k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 376| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 376| else if constexpr (N == 6) { 268| 376| static constexpr auto packed = pack_buffered(); 269| 376| uint64_t in{}; 270| 376| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 376| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 376| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 410| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| 410| if constexpr (N == 8) { 250| 410| static constexpr auto packed = pack(); 251| 410| uint64_t in; 252| 410| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 410| return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 410| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 284| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 284| else if constexpr (N == 6) { 268| 284| static constexpr auto packed = pack_buffered(); 269| 284| uint64_t in{}; 270| 284| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 284| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 284| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 97| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| 97| else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| 97| return 0 == std::memcmp(Str.data(), other, N); 323| 97| } 324| 97| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 77| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 77| else if constexpr (N == 6) { 268| 77| static constexpr auto packed = pack_buffered(); 269| 77| uint64_t in{}; 270| 77| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 77| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 77| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 160| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 160| else if constexpr (N == 6) { 268| 160| static constexpr auto packed = pack_buffered(); 269| 160| uint64_t in{}; 270| 160| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 160| return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 160| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSB_: 245| 1.19k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| 1.19k| else if constexpr (N == 4) { 286| 1.19k| static constexpr auto packed = pack(); 287| 1.19k| uint32_t in; 288| 1.19k| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 1.19k| return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 1.19k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 68.1k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| 68.1k| if constexpr (N == 8) { 250| 68.1k| static constexpr auto packed = pack(); 251| 68.1k| uint64_t in; 252| 68.1k| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 68.1k| return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 68.1k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 55.9k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| 55.9k| else if constexpr (N == 7) { 259| 55.9k| static constexpr auto packed = pack_buffered(); 260| 55.9k| uint64_t in{}; 261| 55.9k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 55.9k| return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 55.9k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 39.6k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| 39.6k| else if constexpr (N == 7) { 259| 39.6k| static constexpr auto packed = pack_buffered(); 260| 39.6k| uint64_t in{}; 261| 39.6k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 39.6k| return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 39.6k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm3EcEEbPKT1_: 245| 84.2k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 84.2k| else if constexpr (N == 3) { 295| 84.2k| static constexpr auto packed = pack(); 296| 84.2k| uint16_t in; 297| 84.2k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 84.2k| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 84.2k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSB_: 245| 218k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| 218k| else if constexpr (N == 4) { 286| 218k| static constexpr auto packed = pack(); 287| 218k| uint32_t in; 288| 218k| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 218k| return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 218k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSD_: 245| 4.45k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 4.45k| else if constexpr (N == 3) { 295| 4.45k| static constexpr auto packed = pack(); 296| 4.45k| uint16_t in; 297| 4.45k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 4.45k| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 4.45k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm4EcEEbPKSD_: 245| 3.04k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| 3.04k| else if constexpr (N == 4) { 286| 3.04k| static constexpr auto packed = pack(); 287| 3.04k| uint32_t in; 288| 3.04k| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 3.04k| return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 3.04k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSD_: 245| 2.47k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 2.47k| else if constexpr (N == 3) { 295| 2.47k| static constexpr auto packed = pack(); 296| 2.47k| uint16_t in; 297| 2.47k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 2.47k| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 2.47k| } _ZN3glz10comparitorIL_ZZZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDavE3keyELm2EcEEbPKSC_: 245| 16.3k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| 16.3k| else if constexpr (N == 2) { 304| 16.3k| static constexpr auto packed = pack(); 305| 16.3k| uint16_t in; 306| 16.3k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 16.3k| return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 16.3k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm3EcEEbPKSE_: 245| 845| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 845| else if constexpr (N == 3) { 295| 845| static constexpr auto packed = pack(); 296| 845| uint16_t in; 297| 845| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 845| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 845| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm4EcEEbPKSE_: 245| 872| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| 872| else if constexpr (N == 4) { 286| 872| static constexpr auto packed = pack(); 287| 872| uint32_t in; 288| 872| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 872| return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 872| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_Qntcl15check_is_paddedT0_EEEvSF_OSG_T3_E1SELm3EcEEbPKSE_: 245| 905| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| 905| else if constexpr (N == 3) { 295| 905| static constexpr auto packed = pack(); 296| 905| uint16_t in; 297| 905| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 905| return (in == packed) & (Str[2] == other[2]); 302| | } 303| | else if constexpr (N == 2) { 304| | static constexpr auto packed = pack(); 305| | uint16_t in; 306| | std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| | return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 905| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 112| 1.01M| { 113| 1.01M| if constexpr (Checked && vector_like) { 114| 1.01M| if (ix == b.size()) [[unlikely]] { ------------------ | Branch (114:14): [True: 0, False: 1.01M] ------------------ 115| 0| grow_buffer(b, b.size() == 0 ? 64 : ix + 1); ------------------ | Branch (115:28): [True: 0, False: 0] ------------------ 116| 0| } 117| 1.01M| } 118| 1.01M| assign_maybe_cast(c, b, ix); 119| 1.01M| ++ix; 120| 1.01M| } _ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm: 57| 1.01M| { 58| 1.01M| using V = std::decay_t; 59| 1.01M| using C = std::decay_t; 60| 1.01M| if constexpr (std::same_as) { 61| 1.01M| b[ix] = c; 62| | } 63| | else { 64| | b[ix] = static_cast(c); 65| | } 66| 1.01M| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 154| 9.19M| { 155| 9.19M| const auto n = str.size(); 156| 9.19M| if constexpr (vector_like) { 157| 9.19M| if constexpr (Checked) { 158| 9.19M| const auto k = ix + n; 159| 9.19M| if (ix + n > b.size()) [[unlikely]] { ------------------ | Branch (159:17): [True: 0, False: 9.19M] ------------------ 160| 0| grow_buffer(b, k); 161| 0| } 162| 9.19M| } 163| 9.19M| } 164| 9.19M| std::memcpy(&b[ix], str.data(), n); 165| 9.19M| ix += n; 166| 9.19M| } _ZN3glz16dump_maybe_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 281| 4.76M| { 282| 4.76M| const auto n = str.size(); 283| 4.76M| if (n) { ------------------ | Branch (283:11): [True: 4.76M, False: 0] ------------------ 284| 4.76M| if constexpr (vector_like) { 285| 4.76M| if constexpr (Checked) { 286| 4.76M| const auto k = ix + n; 287| 4.76M| if (k > b.size()) [[unlikely]] { ------------------ | Branch (287:20): [True: 0, False: 4.76M] ------------------ 288| 0| grow_buffer(b, k); 289| 0| } 290| 4.76M| } 291| 4.76M| } 292| 4.76M| std::memcpy(&b[ix], str.data(), n); 293| 4.76M| ix += n; 294| 4.76M| } 295| 4.76M| } _ZN3glz5dumpnINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT0_mRT_Rm: 184| 337k| { 185| 337k| if constexpr (vector_like) { 186| 337k| const auto k = ix + n; 187| 337k| if (k > b.size()) [[unlikely]] { ------------------ | Branch (187:14): [True: 0, False: 337k] ------------------ 188| 0| grow_buffer(b, k); 189| 0| } 190| 337k| } 191| 337k| std::memset(data_at(b, ix), c, n); 192| 337k| ix += n; 193| 337k| } _ZN3glz7data_atINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEDaRT_m: 79| 337k| { 80| | if constexpr (std::is_pointer_v>) { 81| | return b + ix; 82| | } 83| 337k| else { 84| 337k| static_assert(has_data>, 85| 337k| "an output buffer must be contiguous: dump writes through memset and memcpy"); 86| | if constexpr (has_data_offset>) { 87| | assert(ix >= b.data_offset() && "Index before flush offset"); 88| | return b.data() + (ix - b.data_offset()); 89| | } 90| 337k| else { 91| 337k| return b.data() + ix; 92| 337k| } 93| 337k| } 94| 337k| } _ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 112| 455| { 113| | if constexpr (Checked && vector_like) { 114| | if (ix == b.size()) [[unlikely]] { 115| | grow_buffer(b, b.size() == 0 ? 64 : ix + 1); 116| | } 117| | } 118| 455| assign_maybe_cast(c, b, ix); 119| 455| ++ix; 120| 455| } _ZN3glz10fast_float4spanIKcEC2Ev: 438| 1.78M| constexpr span() : ptr(nullptr), length(0) {} _ZN3glz10fast_float10is_integerIcEEbT_: 1481| 727k|fastfloat_really_inline constexpr bool is_integer(UC c) noexcept { 1482| 727k| return !(c > UC('9') || c < UC('0')); ------------------ | Branch (1482:12): [True: 11, False: 727k] | Branch (1482:27): [True: 30, False: 727k] ------------------ 1483| 727k|} _ZN3glz10fast_float11digit_valueIcEEmT_: 1489| 6.85M|fastfloat_really_inline constexpr uint64_t digit_value(UC c) noexcept { 1490| 6.85M| return uint64_t(uint8_t(c) - uint8_t('0')); 1491| 6.85M|} _ZN3glz10fast_float4spanIKcEC2EPS2_m: 436| 919k| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float26loop_parse_if_eight_digitsERPKcS2_Rm: 1679| 26.5k| uint64_t &i) { 1680| | // optimizes better than parse_if_eight_digits_unrolled() for UC = char. 1681| 1.57M| while ((std::distance(p, pend) >= 8) && ------------------ | Branch (1681:10): [True: 1.57M, False: 1.83k] ------------------ 1682| 1.57M| is_made_of_eight_digits_fast(read8_to_u64(p))) { ------------------ | Branch (1682:10): [True: 1.54M, False: 24.7k] ------------------ 1683| 1.54M| i = i * 100000000 + 1684| 1.54M| parse_eight_digits_unrolled(read8_to_u64( 1685| 1.54M| p)); // in rare cases, this will overflow, but that's ok 1686| 1.54M| p += 8; 1687| 1.54M| } 1688| 26.5k|} _ZN3glz10fast_float28is_made_of_eight_digits_fastEm: 1597| 1.57M|is_made_of_eight_digits_fast(uint64_t val) noexcept { 1598| 1.57M| return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) & 1599| 1.57M| 0x8080808080808080)); 1600| 1.57M|} _ZN3glz10fast_float12read8_to_u64IcEEmPKT_: 1503| 3.42M|read8_to_u64(UC const *chars) { 1504| 3.42M| if (cpp20_and_in_constexpr() || !std::is_same::value) { ------------------ | Branch (1504:7): [Folded, False: 0] | Branch (1504:35): [Folded, False: 0] ------------------ 1505| 0| uint64_t val = 0; 1506| 0| for (int i = 0; i < 8; ++i) { ------------------ | Branch (1506:21): [True: 0, False: 0] ------------------ 1507| 0| val |= uint64_t(uint8_t(*chars)) << (i * 8); 1508| 0| ++chars; 1509| 0| } 1510| 0| return val; 1511| 0| } 1512| 3.42M| uint64_t val; 1513| 3.42M| ::memcpy(&val, chars, sizeof(uint64_t)); 1514| |#if GLZ_FASTFLOAT_IS_BIG_ENDIAN == 1 1515| | // Need to read as-if the number was in little-endian order. 1516| | val = byteswap(val); 1517| |#endif 1518| 3.42M| return val; 1519| 3.42M|} _ZN3glz10fast_float27parse_eight_digits_unrolledEm: 1575| 1.85M|parse_eight_digits_unrolled(uint64_t val) { 1576| 1.85M| uint64_t const mask = 0x000000FF000000FF; 1577| 1.85M| uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32) 1578| 1.85M| uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32) 1579| 1.85M| val -= 0x3030303030303030; 1580| 1.85M| val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8; 1581| 1.85M| val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32; 1582| 1.85M| return uint32_t(val); 1583| 1.85M|} _ZNK3glz10fast_float4spanIKcE3lenEv: 440| 68.6k| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float19from_chars_advancedIdcEENS0_19from_chars_result_tIT0_EERNS0_22parsed_number_string_tIS3_EERT_: 4249| 891k|from_chars_advanced(parsed_number_string_t &pns, T &value) noexcept { 4250| | 4251| 891k| static_assert(is_supported_float_type::value, 4252| 891k| "only some floating-point types are supported"); 4253| 891k| static_assert(is_supported_char_type::value, 4254| 891k| "only char, wchar_t, char16_t and char32_t are supported"); 4255| | 4256| 891k| from_chars_result_t answer; 4257| | 4258| 891k| answer.ec = std::errc(); // be optimistic 4259| 891k| answer.ptr = pns.lastmatch; 4260| | // The implementation of the Clinger's fast path is convoluted because 4261| | // we want round-to-nearest in all cases, irrespective of the rounding mode 4262| | // selected on the thread. 4263| | // We proceed optimistically, assuming that detail::rounds_to_nearest() 4264| | // returns true. 4265| 891k| if (binary_format::min_exponent_fast_path() <= pns.exponent && ------------------ | Branch (4265:7): [True: 886k, False: 5.04k] ------------------ 4266| 886k| pns.exponent <= binary_format::max_exponent_fast_path() && ------------------ | Branch (4266:7): [True: 880k, False: 5.73k] ------------------ 4267| 880k| !pns.too_many_digits) { ------------------ | Branch (4267:7): [True: 860k, False: 19.8k] ------------------ 4268| | // Unfortunately, the conventional Clinger's fast path is only possible 4269| | // when the system rounds to the nearest float. 4270| | // 4271| | // We expect the next branch to almost always be selected. 4272| | // We could check it first (before the previous branch), but 4273| | // there might be performance advantages at having the check 4274| | // be last. 4275| 860k| if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) { ------------------ | Branch (4275:9): [True: 860k, Folded] | Branch (4275:38): [True: 860k, False: 0] ------------------ 4276| | // We have that fegetround() == FE_TONEAREST. 4277| | // Next is Clinger's fast path. 4278| 860k| if (pns.mantissa <= binary_format::max_mantissa_fast_path()) { ------------------ | Branch (4278:11): [True: 858k, False: 2.61k] ------------------ 4279| 858k| value = T(pns.mantissa); 4280| 858k| if (pns.exponent < 0) { ------------------ | Branch (4280:13): [True: 3.88k, False: 854k] ------------------ 4281| 3.88k| value = value / binary_format::exact_power_of_ten(-pns.exponent); 4282| 854k| } else { 4283| 854k| value = value * binary_format::exact_power_of_ten(pns.exponent); 4284| 854k| } 4285| 858k| if (pns.negative) { ------------------ | Branch (4285:13): [True: 726k, False: 131k] ------------------ 4286| 726k| value = -value; 4287| 726k| } 4288| 858k| return answer; 4289| 858k| } 4290| 860k| } else { 4291| | // We do not have that fegetround() == FE_TONEAREST. 4292| | // Next is a modified Clinger's fast path, inspired by Jakub Jelínek's 4293| | // proposal 4294| 0| if (pns.exponent >= 0 && ------------------ | Branch (4294:11): [True: 0, False: 0] ------------------ 4295| 0| pns.mantissa <= ------------------ | Branch (4295:11): [True: 0, False: 0] ------------------ 4296| 0| binary_format::max_mantissa_fast_path(pns.exponent)) { 4297| 0|#if defined(__clang__) || defined(GLZ_FASTFLOAT_32BIT) 4298| | // Clang may map 0 to -0.0 when fegetround() == FE_DOWNWARD 4299| 0| if (pns.mantissa == 0) { ------------------ | Branch (4299:13): [True: 0, False: 0] ------------------ 4300| 0| value = pns.negative ? T(-0.) : T(0.); ------------------ | Branch (4300:19): [True: 0, False: 0] ------------------ 4301| 0| return answer; 4302| 0| } 4303| 0|#endif 4304| 0| value = T(pns.mantissa) * 4305| 0| binary_format::exact_power_of_ten(pns.exponent); 4306| 0| if (pns.negative) { ------------------ | Branch (4306:13): [True: 0, False: 0] ------------------ 4307| 0| value = -value; 4308| 0| } 4309| 0| return answer; 4310| 0| } 4311| 0| } 4312| 860k| } 4313| 33.2k| adjusted_mantissa am = 4314| 33.2k| compute_float>(pns.exponent, pns.mantissa); 4315| 33.2k| if (pns.too_many_digits && am.power2 >= 0) { ------------------ | Branch (4315:7): [True: 25.9k, False: 7.25k] | Branch (4315:30): [True: 25.9k, False: 0] ------------------ 4316| 25.9k| if (am != compute_float>(pns.exponent, pns.mantissa + 1)) { ------------------ | Branch (4316:9): [True: 17.4k, False: 8.54k] ------------------ 4317| 17.4k| am = compute_error>(pns.exponent, pns.mantissa); 4318| 17.4k| } 4319| 25.9k| } 4320| | // If we called compute_float>(pns.exponent, pns.mantissa) 4321| | // and we have an invalid power (am.power2 < 0), then we need to go the long 4322| | // way around again. This is very uncommon. 4323| 33.2k| if (am.power2 < 0) { ------------------ | Branch (4323:7): [True: 17.4k, False: 15.8k] ------------------ 4324| 17.4k| am = digit_comp(pns, am); 4325| 17.4k| } 4326| 33.2k| to_float(pns.negative, am, value); 4327| | // Test for over/underflow. 4328| 33.2k| if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) || ------------------ | Branch (4328:8): [True: 32.9k, False: 323] | Branch (4328:29): [True: 1.52k, False: 31.3k] | Branch (4328:49): [True: 114, False: 1.40k] ------------------ 4329| 33.1k| am.power2 == binary_format::infinite_power()) { ------------------ | Branch (4329:7): [True: 202, False: 32.9k] ------------------ 4330| 316| answer.ec = std::errc::result_out_of_range; 4331| 316| } 4332| 33.2k| return answer; 4333| 891k|} _ZN3glz10fast_float13binary_formatIdE22min_exponent_fast_pathEv: 695| 891k|inline constexpr int binary_format::min_exponent_fast_path() { 696| |#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0) 697| | return 0; 698| |#else 699| 891k| return -22; 700| 891k|#endif 701| 891k|} _ZN3glz10fast_float13binary_formatIdE22max_exponent_fast_pathEv: 767| 886k|inline constexpr int binary_format::max_exponent_fast_path() { 768| 886k| return 22; 769| 886k|} _ZN3glz10fast_float6detail17rounds_to_nearestEv: 4129| 860k|fastfloat_really_inline bool rounds_to_nearest() noexcept { 4130| | // https://lemire.me/blog/2020/06/26/gcc-not-nearest/ 4131| |#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0) 4132| | return false; 4133| |#endif 4134| | // See 4135| | // A fast function to check your floating-point rounding mode 4136| | // https://lemire.me/blog/2022/11/16/a-fast-function-to-check-your-floating-point-rounding-mode/ 4137| | // 4138| | // This function is meant to be equivalent to : 4139| | // prior: #include 4140| | // return fegetround() == FE_TONEAREST; 4141| | // However, it is expected to be much faster than the fegetround() 4142| | // function call. 4143| | // 4144| | // The volatile keyword prevents the compiler from computing the function 4145| | // at compile-time. 4146| | // There might be other ways to prevent compile-time optimizations (e.g., 4147| | // asm). The value does not need to be std::numeric_limits::min(), any 4148| | // small value so that 1 + x should round to 1 would do (after accounting for 4149| | // excess precision, as in 387 instructions). 4150| 860k| static float volatile fmin = (std::numeric_limits::min)(); 4151| 860k| float fmini = fmin; // we copy it so that it gets loaded at most once. 4152| |// 4153| |// Explanation: 4154| |// Only when fegetround() == FE_TONEAREST do we have that 4155| |// fmin + 1.0f == 1.0f - fmin. 4156| |// 4157| |// FE_UPWARD: 4158| |// fmin + 1.0f > 1 4159| |// 1.0f - fmin == 1 4160| |// 4161| |// FE_DOWNWARD or FE_TOWARDZERO: 4162| |// fmin + 1.0f == 1 4163| |// 1.0f - fmin < 1 4164| |// 4165| |// Note: This may fail to be accurate if fast-math has been 4166| |// enabled, as rounding conventions may not apply. 4167| |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO 4168| |#pragma warning(push) 4169| |// todo: is there a VS warning? 4170| |// see 4171| |// https://stackoverflow.com/questions/46079446/is-there-a-warning-for-floating-point-equality-checking-in-visual-studio-2013 4172| |#elif defined(__clang__) 4173| |#pragma clang diagnostic push 4174| 860k|#pragma clang diagnostic ignored "-Wfloat-equal" 4175| |#elif defined(__GNUC__) 4176| |#pragma GCC diagnostic push 4177| |#pragma GCC diagnostic ignored "-Wfloat-equal" 4178| |#endif 4179| 860k| return (fmini + 1.0f == 1.0f - fmini); 4180| |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO 4181| |#pragma warning(pop) 4182| |#elif defined(__clang__) 4183| |#pragma clang diagnostic pop 4184| |#elif defined(__GNUC__) 4185| |#pragma GCC diagnostic pop 4186| |#endif 4187| 860k|} _ZN3glz10fast_float13binary_formatIdE22max_mantissa_fast_pathEv: 777| 860k|inline constexpr uint64_t binary_format::max_mantissa_fast_path() { 778| 860k| return uint64_t(2) << mantissa_explicit_bits(); 779| 860k|} _ZN3glz10fast_float13binary_formatIdE22mantissa_explicit_bitsEv: 713| 1.22M|inline constexpr int binary_format::mantissa_explicit_bits() { 714| 1.22M| return 52; 715| 1.22M|} _ZN3glz10fast_float13binary_formatIdE18exact_power_of_tenEl: 1057| 858k|binary_format::exact_power_of_ten(int64_t power) { 1058| | // Work around clang bug https://godbolt.org/z/zedh7rrhc 1059| 858k| return (void)powers_of_ten[0], powers_of_ten[power]; 1060| 858k|} _ZN3glz10fast_float13compute_floatINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2852| 59.2k|compute_float(int64_t q, uint64_t w) noexcept { 2853| 59.2k| adjusted_mantissa answer; 2854| 59.2k| if ((w == 0) || (q < binary::smallest_power_of_ten())) { ------------------ | Branch (2854:7): [True: 323, False: 58.8k] | Branch (2854:19): [True: 115, False: 58.7k] ------------------ 2855| 438| answer.power2 = 0; 2856| 438| answer.mantissa = 0; 2857| | // result should be zero 2858| 438| return answer; 2859| 438| } 2860| 58.7k| if (q > binary::largest_power_of_ten()) { ------------------ | Branch (2860:7): [True: 250, False: 58.5k] ------------------ 2861| | // we want to get infinity: 2862| 250| answer.power2 = binary::infinite_power(); 2863| 250| answer.mantissa = 0; 2864| 250| return answer; 2865| 250| } 2866| | // At this point in time q is in [powers::smallest_power_of_five, 2867| | // powers::largest_power_of_five]. 2868| | 2869| | // We want the most significant bit of i to be 1. Shift if needed. 2870| 58.5k| int lz = leading_zeroes(w); 2871| 58.5k| w <<= lz; 2872| | 2873| | // The required precision is binary::mantissa_explicit_bits() + 3 because 2874| | // 1. We need the implicit bit 2875| | // 2. We need an extra bit for rounding purposes 2876| | // 3. We might lose a bit due to the "upperbit" routine (result too small, 2877| | // requiring a shift) 2878| | 2879| 58.5k| value128 product = 2880| 58.5k| compute_product_approximation(q, w); 2881| | // The computed 'product' is always sufficient. 2882| | // Mathematical proof: 2883| | // Noble Mushtak and Daniel Lemire, Fast Number Parsing Without Fallback (to 2884| | // appear) See script/mushtak_lemire.py 2885| | 2886| | // The "compute_product_approximation" function can be slightly slower than a 2887| | // branchless approach: value128 product = compute_product(q, w); but in 2888| | // practice, we can win big with the compute_product_approximation if its 2889| | // additional branch is easily predicted. Which is best is data specific. 2890| 58.5k| int upperbit = int(product.high >> 63); 2891| 58.5k| int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3; 2892| | 2893| 58.5k| answer.mantissa = product.high >> shift; 2894| | 2895| 58.5k| answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - 2896| 58.5k| binary::minimum_exponent()); 2897| 58.5k| if (answer.power2 <= 0) { // we have a subnormal? ------------------ | Branch (2897:7): [True: 3.10k, False: 55.4k] ------------------ 2898| | // Here have that answer.power2 <= 0 so -answer.power2 >= 0 2899| 3.10k| if (-answer.power2 + 1 >= ------------------ | Branch (2899:9): [True: 5, False: 3.09k] ------------------ 2900| 3.10k| 64) { // if we have more than 64 bits below the minimum exponent, you 2901| | // have a zero for sure. 2902| 5| answer.power2 = 0; 2903| 5| answer.mantissa = 0; 2904| | // result should be zero 2905| 5| return answer; 2906| 5| } 2907| | // next line is safe because -answer.power2 + 1 < 64 2908| 3.09k| answer.mantissa >>= -answer.power2 + 1; 2909| | // Thankfully, we can't have both "round-to-even" and subnormals because 2910| | // "round-to-even" only occurs for powers close to 0 in the 32-bit and 2911| | // and 64-bit case (with no more than 19 digits). 2912| 3.09k| answer.mantissa += (answer.mantissa & 1); // round up 2913| 3.09k| answer.mantissa >>= 1; 2914| | // There is a weird scenario where we don't have a subnormal but just. 2915| | // Suppose we start with 2.2250738585072013e-308, we end up 2916| | // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal 2917| | // whereas 0x40000000000000 x 2^-1023-53 is normal. Now, we need to round 2918| | // up 0x3fffffffffffff x 2^-1023-53 and once we do, we are no longer 2919| | // subnormal, but we can only know this after rounding. 2920| | // So we only declare a subnormal if we are smaller than the threshold. 2921| 3.09k| answer.power2 = 2922| 3.09k| (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ------------------ | Branch (2922:9): [True: 3.09k, False: 0] ------------------ 2923| 3.09k| ? 0 2924| 3.09k| : 1; 2925| 3.09k| return answer; 2926| 3.10k| } 2927| | 2928| | // usually, we round *up*, but if we fall right in between and and we have an 2929| | // even basis, we need to round down 2930| | // We are only concerned with the cases where 5**q fits in single 64-bit word. 2931| 55.4k| if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) && ------------------ | Branch (2931:7): [True: 21.8k, False: 33.5k] | Branch (2931:29): [True: 21.2k, False: 649] ------------------ 2932| 21.2k| (q <= binary::max_exponent_round_to_even()) && ------------------ | Branch (2932:7): [True: 20.5k, False: 642] ------------------ 2933| 20.5k| ((answer.mantissa & 3) == 1)) { // we may fall between two floats! ------------------ | Branch (2933:7): [True: 14.7k, False: 5.79k] ------------------ 2934| | // To be in-between two floats we need that in doing 2935| | // answer.mantissa = product.high >> (upperbit + 64 - 2936| | // binary::mantissa_explicit_bits() - 3); 2937| | // ... we dropped out only zeroes. But if this happened, then we can go 2938| | // back!!! 2939| 14.7k| if ((answer.mantissa << shift) == product.high) { ------------------ | Branch (2939:9): [True: 7.67k, False: 7.11k] ------------------ 2940| 7.67k| answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up 2941| 7.67k| } 2942| 14.7k| } 2943| | 2944| 55.4k| answer.mantissa += (answer.mantissa & 1); // round up 2945| 55.4k| answer.mantissa >>= 1; 2946| 55.4k| if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) { ------------------ | Branch (2946:7): [True: 1.16k, False: 54.2k] ------------------ 2947| 1.16k| answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits()); 2948| 1.16k| answer.power2++; // undo previous addition 2949| 1.16k| } 2950| | 2951| 55.4k| answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits()); 2952| 55.4k| if (answer.power2 >= binary::infinite_power()) { // infinity ------------------ | Branch (2952:7): [True: 12, False: 55.4k] ------------------ 2953| 12| answer.power2 = binary::infinite_power(); 2954| 12| answer.mantissa = 0; 2955| 12| } 2956| 55.4k| return answer; 2957| 58.5k|} _ZN3glz10fast_float17adjusted_mantissaC2Ev: 568| 94.0k| adjusted_mantissa() = default; _ZN3glz10fast_float13binary_formatIdE21smallest_power_of_tenEv: 1077| 58.8k|inline constexpr int binary_format::smallest_power_of_ten() { 1078| 58.8k| return -342; 1079| 58.8k|} _ZN3glz10fast_float13binary_formatIdE20largest_power_of_tenEv: 1068| 58.7k|template <> inline constexpr int binary_format::largest_power_of_ten() { 1069| 58.7k| return 308; 1070| 58.7k|} _ZN3glz10fast_float14leading_zeroesEm: 488| 84.0k|leading_zeroes(uint64_t input_num) { 489| 84.0k| assert(input_num > 0); ------------------ | Branch (489:3): [True: 84.0k, False: 0] ------------------ 490| 84.0k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (490:7): [Folded, False: 84.0k] ------------------ 491| 0| return leading_zeroes_generic(input_num); 492| 0| } 493| |#ifdef GLZ_FASTFLOAT_VISUAL_STUDIO 494| |#if defined(_M_X64) || defined(_M_ARM64) 495| | unsigned long leading_zero = 0; 496| | // Search the mask data from most significant bit (MSB) 497| | // to least significant bit (LSB) for a set bit (1). 498| | _BitScanReverse64(&leading_zero, input_num); 499| | return (int)(63 - leading_zero); 500| |#else 501| | return leading_zeroes_generic(input_num); 502| |#endif 503| |#else 504| 84.0k| return __builtin_clzll(input_num); 505| 84.0k|#endif 506| 84.0k|} _ZN3glz10fast_float29compute_product_approximationILi55EEENS0_8value128Elm: 2771| 75.9k|compute_product_approximation(int64_t q, uint64_t w) { 2772| 75.9k| int const index = 2 * int(q - powers::smallest_power_of_five); 2773| | // For small values of q, e.g., q in [0,27], the answer is always exact 2774| | // because The line value128 firstproduct = full_multiplication(w, 2775| | // power_of_five_128[index]); gives the exact answer. 2776| 75.9k| value128 firstproduct = 2777| 75.9k| full_multiplication(w, powers::power_of_five_128[index]); 2778| 75.9k| static_assert((bit_precision >= 0) && (bit_precision <= 64), 2779| 75.9k| " precision should be in (0,64]"); 2780| 75.9k| constexpr uint64_t precision_mask = 2781| 75.9k| (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision) ------------------ | Branch (2781:7): [True: 0, Folded] ------------------ 2782| 75.9k| : uint64_t(0xFFFFFFFFFFFFFFFF); 2783| 75.9k| if ((firstproduct.high & precision_mask) == ------------------ | Branch (2783:7): [True: 8.21k, False: 67.7k] ------------------ 2784| 75.9k| precision_mask) { // could further guard with (lower + w < lower) 2785| | // regarding the second product, we only need secondproduct.high, but our 2786| | // expectation is that the compiler will optimize this extra work away if 2787| | // needed. 2788| 8.21k| value128 secondproduct = 2789| 8.21k| full_multiplication(w, powers::power_of_five_128[index + 1]); 2790| 8.21k| firstproduct.low += secondproduct.high; 2791| 8.21k| if (secondproduct.high > firstproduct.low) { ------------------ | Branch (2791:9): [True: 3.46k, False: 4.74k] ------------------ 2792| 3.46k| firstproduct.high++; 2793| 3.46k| } 2794| 8.21k| } 2795| 75.9k| return firstproduct; 2796| 75.9k|} _ZN3glz10fast_float19full_multiplicationEmm: 540| 84.1k|full_multiplication(uint64_t a, uint64_t b) { 541| 84.1k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (541:7): [Folded, False: 84.1k] ------------------ 542| 0| value128 answer; 543| 0| answer.low = umul128_generic(a, b, &answer.high); 544| 0| return answer; 545| 0| } 546| 84.1k| value128 answer; 547| |#if defined(_M_ARM64) && !defined(__MINGW32__) 548| | // ARM64 has native support for 64-bit multiplications, no need to emulate 549| | // But MinGW on ARM64 doesn't have native support for 64-bit multiplications 550| | answer.high = __umulh(a, b); 551| | answer.low = a * b; 552| |#elif defined(GLZ_FASTFLOAT_32BIT) || \ 553| | (defined(_WIN64) && !defined(__clang__) && !defined(_M_ARM64)) 554| | answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64 555| |#elif defined(GLZ_FASTFLOAT_64BIT) && defined(__SIZEOF_INT128__) 556| | __uint128_t r = ((__uint128_t)a) * b; 557| 84.1k| answer.low = uint64_t(r); 558| 84.1k| answer.high = uint64_t(r >> 64); 559| |#else 560| | answer.low = umul128_generic(a, b, &answer.high); 561| |#endif 562| 84.1k| return answer; 563| 84.1k|} _ZN3glz10fast_float8value128C2Ev: 454| 84.1k| constexpr value128() : low(0), high(0) {} _ZN3glz10fast_float6detail5powerEi: 2814| 75.9k|constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept { 2815| 75.9k| return (((152170 + 65536) * q) >> 16) + 63; 2816| 75.9k|} _ZN3glz10fast_float13binary_formatIdE16minimum_exponentEv: 742| 93.4k|template <> inline constexpr int binary_format::minimum_exponent() { 743| 93.4k| return -1023; 744| 93.4k|} _ZN3glz10fast_float13binary_formatIdE26min_exponent_round_to_evenEv: 733| 21.8k|inline constexpr int binary_format::min_exponent_round_to_even() { 734| 21.8k| return -4; 735| 21.8k|} _ZN3glz10fast_float13binary_formatIdE26max_exponent_round_to_evenEv: 723| 21.2k|inline constexpr int binary_format::max_exponent_round_to_even() { 724| 21.2k| return 23; 725| 21.2k|} _ZNK3glz10fast_float17adjusted_mantissaneERKS1_: 574| 25.9k| constexpr bool operator!=(adjusted_mantissa const &o) const { 575| 25.9k| return mantissa != o.mantissa || power2 != o.power2; ------------------ | Branch (575:12): [True: 17.4k, False: 8.54k] | Branch (575:38): [True: 0, False: 8.54k] ------------------ 576| 25.9k| } _ZN3glz10fast_float13compute_errorINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2837| 17.4k|compute_error(int64_t q, uint64_t w) noexcept { 2838| 17.4k| int lz = leading_zeroes(w); 2839| 17.4k| w <<= lz; 2840| 17.4k| value128 product = 2841| 17.4k| compute_product_approximation(q, w); 2842| 17.4k| return compute_error_scaled(q, product.high, lz); 2843| 17.4k|} _ZN3glz10fast_float20compute_error_scaledINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElmi: 2823| 17.4k|compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept { 2824| 17.4k| int hilz = int(w >> 63) ^ 1; 2825| 17.4k| adjusted_mantissa answer; 2826| 17.4k| answer.mantissa = w << hilz; 2827| 17.4k| int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent(); 2828| 17.4k| answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + 2829| 17.4k| invalid_am_bias); 2830| 17.4k| return answer; 2831| 17.4k|} _ZN3glz10fast_float10digit_compIdcEENS0_17adjusted_mantissaERNS0_22parsed_number_string_tIT0_EES2_: 4034| 17.4k|digit_comp(parsed_number_string_t &num, adjusted_mantissa am) noexcept { 4035| | // remove the invalid exponent bias 4036| 17.4k| am.power2 -= invalid_am_bias; 4037| | 4038| 17.4k| int32_t sci_exp = scientific_exponent(num); 4039| 17.4k| size_t max_digits = binary_format::max_digits(); 4040| 17.4k| size_t digits = 0; 4041| 17.4k| bigint bigmant; 4042| 17.4k| parse_mantissa(bigmant, num, max_digits, digits); 4043| | // can't underflow, since digits is at most max_digits. 4044| 17.4k| int32_t exponent = sci_exp + 1 - int32_t(digits); 4045| 17.4k| if (exponent >= 0) { ------------------ | Branch (4045:7): [True: 4.05k, False: 13.3k] ------------------ 4046| 4.05k| return positive_digit_comp(bigmant, exponent); 4047| 13.3k| } else { 4048| 13.3k| return negative_digit_comp(bigmant, am, exponent); 4049| 13.3k| } 4050| 17.4k|} _ZN3glz10fast_float19scientific_exponentIcEEiRNS0_22parsed_number_string_tIT_EE: 3640| 17.4k|scientific_exponent(parsed_number_string_t &num) noexcept { 3641| 17.4k| uint64_t mantissa = num.mantissa; 3642| 17.4k| int32_t exponent = int32_t(num.exponent); 3643| 87.1k| while (mantissa >= 10000) { ------------------ | Branch (3643:10): [True: 69.7k, False: 17.4k] ------------------ 3644| 69.7k| mantissa /= 10000; 3645| 69.7k| exponent += 4; 3646| 69.7k| } 3647| 34.8k| while (mantissa >= 100) { ------------------ | Branch (3647:10): [True: 17.4k, False: 17.4k] ------------------ 3648| 17.4k| mantissa /= 100; 3649| 17.4k| exponent += 2; 3650| 17.4k| } 3651| 17.4k| while (mantissa >= 10) { ------------------ | Branch (3651:10): [True: 0, False: 17.4k] ------------------ 3652| 0| mantissa /= 10; 3653| 0| exponent += 1; 3654| 0| } 3655| 17.4k| return exponent; 3656| 17.4k|} _ZN3glz10fast_float13binary_formatIdE10max_digitsEv: 1085| 17.4k|template <> inline constexpr size_t binary_format::max_digits() { 1086| 17.4k| return 769; 1087| 17.4k|} _ZN3glz10fast_float6bigintC2Ev: 3399| 17.4k| GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {} _ZN3glz10fast_float8stackvecILt62EEC2Ev: 3006| 106k| stackvec() = default; _ZN3glz10fast_float14parse_mantissaIcEEvRNS0_6bigintERNS0_22parsed_number_string_tIT_EEmRm: 3859| 17.4k| size_t max_digits, size_t &digits) noexcept { 3860| | // try to minimize the number of big integer and scalar multiplication. 3861| | // therefore, try to parse 8 digits at a time, and multiply by the largest 3862| | // scalar value (9 or 19 digits) for each step. 3863| 17.4k| size_t counter = 0; 3864| 17.4k| digits = 0; 3865| 17.4k| limb value = 0; 3866| 17.4k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3867| 17.4k| size_t step = 19; 3868| |#else 3869| | size_t step = 9; 3870| |#endif 3871| | 3872| | // process all integer digits. 3873| 17.4k| UC const *p = num.integer.ptr; 3874| 17.4k| UC const *pend = p + num.integer.len(); 3875| 17.4k| skip_zeros(p, pend); 3876| | // process all digits, in increments of step per loop 3877| 38.7k| while (p != pend) { ------------------ | Branch (3877:10): [True: 21.2k, False: 17.4k] ------------------ 3878| 51.7k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3878:12): [True: 35.3k, False: 16.4k] | Branch (3878:45): [True: 30.5k, False: 4.80k] ------------------ 3879| 30.5k| (max_digits - digits >= 8)) { ------------------ | Branch (3879:12): [True: 30.5k, False: 0] ------------------ 3880| 30.5k| parse_eight_digits(p, value, counter, digits); 3881| 30.5k| } 3882| 76.9k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3882:12): [True: 64.3k, False: 12.6k] | Branch (3882:30): [True: 55.7k, False: 8.60k] | Branch (3882:43): [True: 55.7k, False: 0] ------------------ 3883| 55.7k| parse_one_digit(p, value, counter, digits); 3884| 55.7k| } 3885| 21.2k| if (digits == max_digits) { ------------------ | Branch (3885:9): [True: 0, False: 21.2k] ------------------ 3886| | // add the temporary value, then check if we've truncated any digits 3887| 0| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3888| 0| bool truncated = is_truncated(p, pend); 3889| 0| if (num.fraction.ptr != nullptr) { ------------------ | Branch (3889:11): [True: 0, False: 0] ------------------ 3890| 0| truncated |= is_truncated(num.fraction); 3891| 0| } 3892| 0| if (truncated) { ------------------ | Branch (3892:11): [True: 0, False: 0] ------------------ 3893| 0| round_up_bigint(result, digits); 3894| 0| } 3895| 0| return; 3896| 21.2k| } else { 3897| 21.2k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3898| 21.2k| counter = 0; 3899| 21.2k| value = 0; 3900| 21.2k| } 3901| 21.2k| } 3902| | 3903| | // add our fraction digits, if they're available. 3904| 17.4k| if (num.fraction.ptr != nullptr) { ------------------ | Branch (3904:7): [True: 14.8k, False: 2.61k] ------------------ 3905| 14.8k| p = num.fraction.ptr; 3906| 14.8k| pend = p + num.fraction.len(); 3907| 14.8k| if (digits == 0) { ------------------ | Branch (3907:9): [True: 2.45k, False: 12.3k] ------------------ 3908| 2.45k| skip_zeros(p, pend); 3909| 2.45k| } 3910| | // process all digits, in increments of step per loop 3911| 162k| while (p != pend) { ------------------ | Branch (3911:12): [True: 150k, False: 12.4k] ------------------ 3912| 431k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3912:14): [True: 417k, False: 14.6k] | Branch (3912:47): [True: 282k, False: 134k] ------------------ 3913| 282k| (max_digits - digits >= 8)) { ------------------ | Branch (3913:14): [True: 281k, False: 1.40k] ------------------ 3914| 281k| parse_eight_digits(p, value, counter, digits); 3915| 281k| } 3916| 601k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3916:14): [True: 465k, False: 135k] | Branch (3916:32): [True: 452k, False: 12.6k] | Branch (3916:45): [True: 450k, False: 1.63k] ------------------ 3917| 450k| parse_one_digit(p, value, counter, digits); 3918| 450k| } 3919| 150k| if (digits == max_digits) { ------------------ | Branch (3919:11): [True: 2.41k, False: 147k] ------------------ 3920| | // add the temporary value, then check if we've truncated any digits 3921| 2.41k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3922| 2.41k| bool truncated = is_truncated(p, pend); 3923| 2.41k| if (truncated) { ------------------ | Branch (3923:13): [True: 1.58k, False: 828] ------------------ 3924| 1.58k| round_up_bigint(result, digits); 3925| 1.58k| } 3926| 2.41k| return; 3927| 147k| } else { 3928| 147k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3929| 147k| counter = 0; 3930| 147k| value = 0; 3931| 147k| } 3932| 150k| } 3933| 14.8k| } 3934| | 3935| 15.0k| if (counter != 0) { ------------------ | Branch (3935:7): [True: 0, False: 15.0k] ------------------ 3936| 0| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3937| 0| } 3938| 15.0k|} _ZN3glz10fast_float10skip_zerosIcEEvRPKT_S4_: 3773| 19.8k|skip_zeros(UC const *&first, UC const *last) noexcept { 3774| 19.8k| uint64_t val; 3775| 48.5k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3775:10): [True: 48.5k, Folded] ------------------ 3776| 48.5k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3776:10): [True: 43.6k, False: 4.89k] ------------------ 3777| 43.6k| ::memcpy(&val, first, sizeof(uint64_t)); 3778| 43.6k| if (val != int_cmp_zeros()) { ------------------ | Branch (3778:9): [True: 14.9k, False: 28.6k] ------------------ 3779| 14.9k| break; 3780| 14.9k| } 3781| 28.6k| first += int_cmp_len(); 3782| 28.6k| } 3783| 26.2k| while (first != last) { ------------------ | Branch (3783:10): [True: 23.8k, False: 2.45k] ------------------ 3784| 23.8k| if (*first != UC('0')) { ------------------ | Branch (3784:9): [True: 17.4k, False: 6.36k] ------------------ 3785| 17.4k| break; 3786| 17.4k| } 3787| 6.36k| first++; 3788| 6.36k| } 3789| 19.8k|} _ZN3glz10fast_float11int_cmp_lenIcEEiv: 1180| 161k|template constexpr int int_cmp_len() { 1181| 161k| return sizeof(uint64_t) / sizeof(UC); 1182| 161k|} _ZN3glz10fast_float13int_cmp_zerosIcEEmv: 1170| 85.6k|template constexpr uint64_t int_cmp_zeros() { 1171| 85.6k| static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4), 1172| 85.6k| "Unsupported character size"); 1173| 85.6k| return (sizeof(UC) == 1) ? 0x3030303030303030 ------------------ | Branch (1173:10): [True: 85.6k, Folded] ------------------ 1174| 85.6k| : (sizeof(UC) == 2) ------------------ | Branch (1174:12): [Folded, False: 0] ------------------ 1175| 0| ? (uint64_t(UC('0')) << 48 | uint64_t(UC('0')) << 32 | 1176| 0| uint64_t(UC('0')) << 16 | UC('0')) 1177| 0| : (uint64_t(UC('0')) << 32 | UC('0')); 1178| 85.6k|} _ZN3glz10fast_float18parse_eight_digitsIcEEvRPKT_RmS6_S6_: 3824| 311k| size_t &count) noexcept { 3825| 311k| value = value * 100000000 + parse_eight_digits_unrolled(p); 3826| 311k| p += 8; 3827| 311k| counter += 8; 3828| 311k| count += 8; 3829| 311k|} _ZN3glz10fast_float27parse_eight_digits_unrolledIcEEjPKT_: 1588| 311k|parse_eight_digits_unrolled(UC const *chars) noexcept { 1589| 311k| if (cpp20_and_in_constexpr() || !has_simd_opt()) { ------------------ | Branch (1589:7): [Folded, False: 0] | Branch (1589:35): [True: 0, Folded] ------------------ 1590| 311k| return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay 1591| 311k| } 1592| 0| return parse_eight_digits_unrolled(simd_read8_to_u64(chars)); 1593| 311k|} _ZN3glz10fast_float15parse_one_digitIcEEvRPKT_RmS6_S6_: 3834| 506k| size_t &count) noexcept { 3835| 506k| value = value * 10 + limb(*p - UC('0')); 3836| 506k| p++; 3837| 506k| counter++; 3838| 506k| count++; 3839| 506k|} _ZN3glz10fast_float10add_nativeERNS0_6bigintEmm: 3842| 173k|add_native(bigint &big, limb power, limb value) noexcept { 3843| 173k| big.mul(power); 3844| 173k| big.add(value); 3845| 173k|} _ZN3glz10fast_float6bigint3mulEm: 3552| 173k| GLZ_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); } _ZN3glz10fast_float9small_mulILt62EEEbRNS0_8stackvecIXT_EEEm: 3249| 300k| limb y) noexcept { 3250| 300k| limb carry = 0; 3251| 3.97M| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3251:26): [True: 3.67M, False: 300k] ------------------ 3252| 3.67M| vec[index] = scalar_mul(vec[index], y, carry); 3253| 3.67M| } 3254| 300k| if (carry != 0) { ------------------ | Branch (3254:7): [True: 265k, False: 34.1k] ------------------ 3255| 265k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 265k| { \ | | 355| 265k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 265k] | | ------------------ | | 356| 265k| return false; \ | | 357| 265k| } ------------------ 3256| 265k| } 3257| 300k| return true; 3258| 300k|} _ZNK3glz10fast_float8stackvecILt62EE3lenEv: 3039| 5.30M| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float10scalar_mulEmmRm: 3196| 3.67M|scalar_mul(limb x, limb y, limb &carry) noexcept { 3197| 3.67M|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3198| 3.67M|#if defined(__SIZEOF_INT128__) 3199| | // GCC and clang both define it as an extension. 3200| 3.67M| __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry); 3201| 3.67M| carry = limb(z >> limb_bits); 3202| 3.67M| return limb(z); 3203| |#else 3204| | // fallback, no native 128-bit integer multiplication with carry. 3205| | // on msvc, this optimizes identically, somehow. 3206| | value128 z = full_multiplication(x, y); 3207| | bool overflow; 3208| | z.low = scalar_add(z.low, carry, overflow); 3209| | z.high += uint64_t(overflow); // cannot overflow 3210| | carry = z.high; 3211| | return z.low; 3212| |#endif 3213| |#else 3214| | uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry); 3215| | carry = limb(z >> limb_bits); 3216| | return limb(z); 3217| |#endif 3218| 3.67M|} _ZN3glz10fast_float8stackvecILt62EEixEm: 3017| 9.18M| GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept { 3018| 9.18M| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 9.18M| { ((void)(x)); } ------------------ 3019| 9.18M| return data[index]; 3020| 9.18M| } _ZN3glz10fast_float8stackvecILt62EE8try_pushEm: 3052| 289k| GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept { 3053| 289k| if (len() < capacity()) { ------------------ | Branch (3053:9): [True: 289k, False: 0] ------------------ 3054| 289k| push_unchecked(value); 3055| 289k| return true; 3056| 289k| } else { 3057| 0| return false; 3058| 0| } 3059| 289k| } _ZNK3glz10fast_float8stackvecILt62EE8capacityEv: 3043| 465k| constexpr size_t capacity() const noexcept { return size; } _ZN3glz10fast_float8stackvecILt62EE14push_uncheckedEm: 3046| 302k| GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept { 3047| 302k| data[length] = value; 3048| 302k| length++; 3049| 302k| } _ZN3glz10fast_float6bigint3addEm: 3554| 173k| GLZ_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); } _ZN3glz10fast_float9small_addILt62EEEbRNS0_8stackvecIXT_EEEm: 3242| 173k|small_add(stackvec &vec, limb y) noexcept { 3243| 173k| return small_add_from(vec, y, 0); 3244| 173k|} _ZN3glz10fast_float14small_add_fromILt62EEEbRNS0_8stackvecIXT_EEEmm: 3224| 173k| size_t start) noexcept { 3225| 173k| size_t index = start; 3226| 173k| limb carry = y; 3227| 173k| bool overflow; 3228| 239k| while (carry != 0 && index < vec.len()) { ------------------ | Branch (3228:10): [True: 84.4k, False: 155k] | Branch (3228:24): [True: 66.3k, False: 18.0k] ------------------ 3229| 66.3k| vec[index] = scalar_add(vec[index], carry, overflow); 3230| 66.3k| carry = limb(overflow); 3231| 66.3k| index += 1; 3232| 66.3k| } 3233| 173k| if (carry != 0) { ------------------ | Branch (3233:7): [True: 18.0k, False: 155k] ------------------ 3234| 18.0k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 18.0k| { \ | | 355| 18.0k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 18.0k] | | ------------------ | | 356| 18.0k| return false; \ | | 357| 18.0k| } ------------------ 3235| 18.0k| } 3236| 173k| return true; 3237| 173k|} _ZN3glz10fast_float10scalar_addEmmRb: 3176| 1.07M|scalar_add(limb x, limb y, bool &overflow) noexcept { 3177| 1.07M| limb z; 3178| |// gcc and clang 3179| 1.07M|#if defined(__has_builtin) 3180| 1.07M|#if __has_builtin(__builtin_add_overflow) 3181| 1.07M| if (!cpp20_and_in_constexpr()) { ------------------ | Branch (3181:7): [True: 1.07M, Folded] ------------------ 3182| 1.07M| overflow = __builtin_add_overflow(x, y, &z); 3183| 1.07M| return z; 3184| 1.07M| } 3185| 0|#endif 3186| 0|#endif 3187| | 3188| | // generic, this still optimizes correctly on MSVC. 3189| 0| z = x + y; 3190| 0| overflow = z < x; 3191| 0| return z; 3192| 1.07M|} _ZN3glz10fast_float12is_truncatedIcEEbPKT_S4_: 3795| 2.41k|is_truncated(UC const *first, UC const *last) noexcept { 3796| | // do 8-bit optimizations, can just compare to 8 literal 0s. 3797| 2.41k| uint64_t val; 3798| 43.4k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3798:10): [True: 43.4k, Folded] ------------------ 3799| 43.4k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3799:10): [True: 41.9k, False: 1.45k] ------------------ 3800| 41.9k| ::memcpy(&val, first, sizeof(uint64_t)); 3801| 41.9k| if (val != int_cmp_zeros()) { ------------------ | Branch (3801:9): [True: 955, False: 41.0k] ------------------ 3802| 955| return true; 3803| 955| } 3804| 41.0k| first += int_cmp_len(); 3805| 41.0k| } 3806| 4.53k| while (first != last) { ------------------ | Branch (3806:10): [True: 3.70k, False: 828] ------------------ 3807| 3.70k| if (*first != UC('0')) { ------------------ | Branch (3807:9): [True: 630, False: 3.07k] ------------------ 3808| 630| return true; 3809| 630| } 3810| 3.07k| ++first; 3811| 3.07k| } 3812| 828| return false; 3813| 1.45k|} _ZN3glz10fast_float15round_up_bigintERNS0_6bigintERm: 3848| 1.58k|round_up_bigint(bigint &big, size_t &count) noexcept { 3849| | // need to round-up the digits, but need to avoid rounding 3850| | // ....9999 to ...10000, which could cause a false halfway point. 3851| 1.58k| add_native(big, 10, 1); 3852| 1.58k| count++; 3853| 1.58k|} _ZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEi: 3942| 4.05k|positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept { 3943| 4.05k| GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent))); ------------------ | | 344| 4.05k| { ((void)(x)); } ------------------ 3944| 4.05k| adjusted_mantissa answer; 3945| 4.05k| bool truncated; 3946| 4.05k| answer.mantissa = bigmant.hi64(truncated); 3947| 4.05k| int bias = binary_format::mantissa_explicit_bits() - 3948| 4.05k| binary_format::minimum_exponent(); 3949| 4.05k| answer.power2 = bigmant.bit_length() - 64 + bias; 3950| | 3951| 4.05k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 4.05k| round_nearest_tie_even( 3953| 4.05k| a, shift, 3954| 4.05k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 4.05k| return is_above || (is_halfway && truncated) || 3956| 4.05k| (is_odd && is_halfway); 3957| 4.05k| }); 3958| 4.05k| }); 3959| | 3960| 4.05k| return answer; 3961| 4.05k|} _ZN3glz10fast_float6bigint5pow10Ej: 3591| 4.05k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept { 3592| 4.05k| GLZ_FASTFLOAT_TRY(pow5(exp)); ------------------ | | 354| 4.05k| { \ | | 355| 4.05k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 4.05k] | | ------------------ | | 356| 4.05k| return false; \ | | 357| 4.05k| } ------------------ 3593| 4.05k| return pow2(exp); 3594| 4.05k| } _ZN3glz10fast_float6bigint4pow5Ej: 3560| 17.4k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept { 3561| | // multiply by a power of 5 3562| 17.4k| size_t large_length = sizeof(large_power_of_5) / sizeof(limb); 3563| 17.4k| limb_span large = limb_span(large_power_of_5, large_length); 3564| 36.4k| while (exp >= large_step) { ------------------ | Branch (3564:12): [True: 18.9k, False: 17.4k] ------------------ 3565| 18.9k| GLZ_FASTFLOAT_TRY(large_mul(vec, large)); ------------------ | | 354| 18.9k| { \ | | 355| 18.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 18.9k] | | ------------------ | | 356| 18.9k| return false; \ | | 357| 18.9k| } ------------------ 3566| 18.9k| exp -= large_step; 3567| 18.9k| } 3568| 17.4k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3569| 17.4k| uint32_t small_step = 27; 3570| 17.4k| limb max_native = 7450580596923828125UL; 3571| |#else 3572| | uint32_t small_step = 13; 3573| | limb max_native = 1220703125U; 3574| |#endif 3575| 35.1k| while (exp >= small_step) { ------------------ | Branch (3575:12): [True: 17.7k, False: 17.4k] ------------------ 3576| 17.7k| GLZ_FASTFLOAT_TRY(small_mul(vec, max_native)); ------------------ | | 354| 17.7k| { \ | | 355| 17.7k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 17.7k] | | ------------------ | | 356| 17.7k| return false; \ | | 357| 17.7k| } ------------------ 3577| 17.7k| exp -= small_step; 3578| 17.7k| } 3579| 17.4k| if (exp != 0) { ------------------ | Branch (3579:9): [True: 14.4k, False: 2.96k] ------------------ 3580| | // Work around clang bug https://godbolt.org/z/zedh7rrhc 3581| | // This is similar to https://github.com/llvm/llvm-project/issues/47746, 3582| | // except the workaround described there don't work here 3583| 14.4k| GLZ_FASTFLOAT_TRY(small_mul( ------------------ | | 354| 14.4k| { \ | | 355| 14.4k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.4k] | | ------------------ | | 356| 14.4k| return false; \ | | 357| 14.4k| } ------------------ 3584| 14.4k| vec, limb(((void)small_power_of_5[0], small_power_of_5[exp])))); 3585| 14.4k| } 3586| | 3587| 17.4k| return true; 3588| 17.4k| } _ZN3glz10fast_float4spanImEC2EPKmm: 436| 131k| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float9large_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3329| 18.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec &x, limb_span y) noexcept { 3330| 18.9k| if (y.len() == 1) { ------------------ | Branch (3330:7): [True: 0, False: 18.9k] ------------------ 3331| 0| GLZ_FASTFLOAT_TRY(small_mul(x, y[0])); ------------------ | | 354| 0| { \ | | 355| 0| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 0] | | ------------------ | | 356| 0| return false; \ | | 357| 0| } ------------------ 3332| 18.9k| } else { 3333| 18.9k| GLZ_FASTFLOAT_TRY(long_mul(x, y)); ------------------ | | 354| 18.9k| { \ | | 355| 18.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 18.9k] | | ------------------ | | 356| 18.9k| return false; \ | | 357| 18.9k| } ------------------ 3334| 18.9k| } 3335| 18.9k| return true; 3336| 18.9k|} _ZNK3glz10fast_float4spanImE3lenEv: 440| 1.37M| constexpr size_t len() const noexcept { return length; } _ZNK3glz10fast_float4spanImEixEm: 442| 823k| GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept { 443| 823k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 823k| { ((void)(x)); } ------------------ 444| 823k| return ptr[index]; 445| 823k| } _ZN3glz10fast_float8long_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3301| 18.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec &x, limb_span y) noexcept { 3302| 18.9k| limb_span xs = limb_span(x.data, x.len()); 3303| 18.9k| stackvec z(xs); 3304| 18.9k| limb_span zs = limb_span(z.data, z.len()); 3305| | 3306| 18.9k| if (y.len() != 0) { ------------------ | Branch (3306:7): [True: 18.9k, False: 0] ------------------ 3307| 18.9k| limb y0 = y[0]; 3308| 18.9k| GLZ_FASTFLOAT_TRY(small_mul(x, y0)); ------------------ | | 354| 18.9k| { \ | | 355| 18.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 18.9k] | | ------------------ | | 356| 18.9k| return false; \ | | 357| 18.9k| } ------------------ 3309| 94.8k| for (size_t index = 1; index < y.len(); index++) { ------------------ | Branch (3309:28): [True: 75.8k, False: 18.9k] ------------------ 3310| 75.8k| limb yi = y[index]; 3311| 75.8k| stackvec zi; 3312| 75.8k| if (yi != 0) { ------------------ | Branch (3312:11): [True: 75.8k, False: 0] ------------------ 3313| | // re-use the same buffer throughout 3314| 75.8k| zi.set_len(0); 3315| 75.8k| GLZ_FASTFLOAT_TRY(zi.try_extend(zs)); ------------------ | | 354| 75.8k| { \ | | 355| 75.8k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 75.8k] | | ------------------ | | 356| 75.8k| return false; \ | | 357| 75.8k| } ------------------ 3316| 75.8k| GLZ_FASTFLOAT_TRY(small_mul(zi, yi)); ------------------ | | 354| 75.8k| { \ | | 355| 75.8k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 75.8k] | | ------------------ | | 356| 75.8k| return false; \ | | 357| 75.8k| } ------------------ 3317| 75.8k| limb_span zis = limb_span(zi.data, zi.len()); 3318| 75.8k| GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index)); ------------------ | | 354| 75.8k| { \ | | 355| 75.8k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 75.8k] | | ------------------ | | 356| 75.8k| return false; \ | | 357| 75.8k| } ------------------ 3319| 75.8k| } 3320| 75.8k| } 3321| 18.9k| } 3322| | 3323| 18.9k| x.normalize(); 3324| 18.9k| return true; 3325| 18.9k|} _ZN3glz10fast_float8stackvecILt62EEC2ENS0_4spanImEE: 3013| 18.9k| GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) { 3014| 18.9k| GLZ_FASTFLOAT_ASSERT(try_extend(s)); ------------------ | | 344| 18.9k| { ((void)(x)); } ------------------ 3015| 18.9k| } _ZN3glz10fast_float8stackvecILt62EE7set_lenEm: 3035| 252k| GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept { 3036| 252k| length = uint16_t(len); 3037| 252k| } _ZN3glz10fast_float8stackvecILt62EE10try_extendENS0_4spanImEE: 3069| 94.8k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept { 3070| 94.8k| if (len() + s.len() <= capacity()) { ------------------ | Branch (3070:9): [True: 94.8k, False: 0] ------------------ 3071| 94.8k| extend_unchecked(s); 3072| 94.8k| return true; 3073| 94.8k| } else { 3074| 0| return false; 3075| 0| } 3076| 94.8k| } _ZN3glz10fast_float8stackvecILt62EE16extend_uncheckedENS0_4spanImEE: 3062| 94.8k| GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept { 3063| 94.8k| limb *ptr = data + length; 3064| 94.8k| std::copy_n(s.ptr, s.len(), ptr); 3065| 94.8k| set_len(len() + s.len()); 3066| 94.8k| } _ZN3glz10fast_float14large_add_fromILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEEm: 3264| 75.8k| size_t start) noexcept { 3265| | // the effective x buffer is from `xstart..x.len()`, so exit early 3266| | // if we can't get that current range. 3267| 75.8k| if (x.len() < start || y.len() > x.len() - start) { ------------------ | Branch (3267:7): [True: 0, False: 75.8k] | Branch (3267:26): [True: 74.7k, False: 1.17k] ------------------ 3268| 74.7k| GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0)); ------------------ | | 354| 74.7k| { \ | | 355| 74.7k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 74.7k] | | ------------------ | | 356| 74.7k| return false; \ | | 357| 74.7k| } ------------------ 3269| 74.7k| } 3270| | 3271| 75.8k| bool carry = false; 3272| 804k| for (size_t index = 0; index < y.len(); index++) { ------------------ | Branch (3272:26): [True: 728k, False: 75.8k] ------------------ 3273| 728k| limb xi = x[index + start]; 3274| 728k| limb yi = y[index]; 3275| 728k| bool c1 = false; 3276| 728k| bool c2 = false; 3277| 728k| xi = scalar_add(xi, yi, c1); 3278| 728k| if (carry) { ------------------ | Branch (3278:9): [True: 284k, False: 444k] ------------------ 3279| 284k| xi = scalar_add(xi, 1, c2); 3280| 284k| } 3281| 728k| x[index + start] = xi; 3282| 728k| carry = c1 | c2; 3283| 728k| } 3284| | 3285| | // handle overflow 3286| 75.8k| if (carry) { ------------------ | Branch (3286:7): [True: 0, False: 75.8k] ------------------ 3287| 0| GLZ_FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start)); ------------------ | | 354| 0| { \ | | 355| 0| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 0] | | ------------------ | | 356| 0| return false; \ | | 357| 0| } ------------------ 3288| 0| } 3289| 75.8k| return true; 3290| 75.8k|} _ZN3glz10fast_float8stackvecILt62EE10try_resizeEmm: 3095| 74.7k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept { 3096| 74.7k| if (new_len > capacity()) { ------------------ | Branch (3096:9): [True: 0, False: 74.7k] ------------------ 3097| 0| return false; 3098| 74.7k| } else { 3099| 74.7k| resize_unchecked(new_len, value); 3100| 74.7k| return true; 3101| 74.7k| } 3102| 74.7k| } _ZN3glz10fast_float8stackvecILt62EE16resize_uncheckedEmm: 3082| 74.7k| void resize_unchecked(size_t new_len, limb value) noexcept { 3083| 74.7k| if (new_len > len()) { ------------------ | Branch (3083:9): [True: 74.7k, False: 0] ------------------ 3084| 74.7k| size_t count = new_len - len(); 3085| 74.7k| limb *first = data + len(); 3086| 74.7k| limb *last = first + count; 3087| 74.7k| ::std::fill(first, last, value); 3088| 74.7k| set_len(new_len); 3089| 74.7k| } else { 3090| 0| set_len(new_len); 3091| 0| } 3092| 74.7k| } _ZN3glz10fast_float8stackvecILt62EE9normalizeEv: 3118| 32.3k| GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept { 3119| 32.3k| while (len() > 0 && rindex(0) == 0) { ------------------ | Branch (3119:12): [True: 32.3k, False: 0] | Branch (3119:25): [True: 0, False: 32.3k] ------------------ 3120| 0| length--; 3121| 0| } 3122| 32.3k| } _ZNK3glz10fast_float8stackvecILt62EE6rindexEm: 3028| 45.6k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept { 3029| 45.6k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 45.6k| { ((void)(x)); } ------------------ 3030| 45.6k| size_t rindex = length - index - 1; 3031| 45.6k| return data[rindex]; 3032| 45.6k| } _ZN3glz10fast_float6bigint4pow2Ej: 3557| 17.2k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); } _ZN3glz10fast_float6bigint3shlEm: 3519| 17.2k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept { 3520| 17.2k| size_t rem = n % limb_bits; 3521| 17.2k| size_t div = n / limb_bits; 3522| 17.2k| if (rem != 0) { ------------------ | Branch (3522:9): [True: 14.4k, False: 2.81k] ------------------ 3523| 14.4k| GLZ_FASTFLOAT_TRY(shl_bits(rem)); ------------------ | | 354| 14.4k| { \ | | 355| 14.4k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.4k] | | ------------------ | | 356| 14.4k| return false; \ | | 357| 14.4k| } ------------------ 3524| 14.4k| } 3525| 17.2k| if (div != 0) { ------------------ | Branch (3525:9): [True: 7.13k, False: 10.1k] ------------------ 3526| 7.13k| GLZ_FASTFLOAT_TRY(shl_limbs(div)); ------------------ | | 354| 7.13k| { \ | | 355| 7.13k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 7.13k] | | ------------------ | | 356| 7.13k| return false; \ | | 357| 7.13k| } ------------------ 3527| 7.13k| } 3528| 17.2k| return true; 3529| 17.2k| } _ZN3glz10fast_float6bigint8shl_bitsEm: 3472| 14.4k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl_bits(size_t n) noexcept { 3473| | // Internally, for each item, we shift left by n, and add the previous 3474| | // right shifted limb-bits. 3475| | // For example, we transform (for u8) shifted left 2, to: 3476| | // b10100100 b01000010 3477| | // b10 b10010001 b00001000 3478| 14.4k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 14.4k| { ((void)(x)); } ------------------ 3479| 14.4k| GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8); ------------------ | | 349| 14.4k| { ((void)(x)); } ------------------ 3480| | 3481| 14.4k| size_t shl = n; 3482| 14.4k| size_t shr = limb_bits - shl; 3483| 14.4k| limb prev = 0; 3484| 141k| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3484:28): [True: 126k, False: 14.4k] ------------------ 3485| 126k| limb xi = vec[index]; 3486| 126k| vec[index] = (xi << shl) | (prev >> shr); 3487| 126k| prev = xi; 3488| 126k| } 3489| | 3490| 14.4k| limb carry = prev >> shr; 3491| 14.4k| if (carry != 0) { ------------------ | Branch (3491:9): [True: 5.11k, False: 9.31k] ------------------ 3492| 5.11k| return vec.try_push(carry); 3493| 5.11k| } 3494| 9.31k| return true; 3495| 14.4k| } _ZN3glz10fast_float6bigint9shl_limbsEm: 3498| 7.13k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept { 3499| 7.13k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 7.13k| { ((void)(x)); } ------------------ 3500| 7.13k| if (n + vec.len() > vec.capacity()) { ------------------ | Branch (3500:9): [True: 0, False: 7.13k] ------------------ 3501| 0| return false; 3502| 7.13k| } else if (!vec.is_empty()) { ------------------ | Branch (3502:16): [True: 7.13k, False: 0] ------------------ 3503| | // move limbs 3504| 7.13k| limb *dst = vec.data + n; 3505| 7.13k| limb const *src = vec.data; 3506| 7.13k| std::copy_backward(src, src + vec.len(), dst + vec.len()); 3507| | // fill in empty limbs 3508| 7.13k| limb *first = vec.data; 3509| 7.13k| limb *last = first + n; 3510| 7.13k| ::std::fill(first, last, 0); 3511| 7.13k| vec.set_len(n + vec.len()); 3512| 7.13k| return true; 3513| 7.13k| } else { 3514| 0| return true; 3515| 0| } 3516| 7.13k| } _ZNK3glz10fast_float8stackvecILt62EE8is_emptyEv: 3041| 11.1k| constexpr bool is_empty() const noexcept { return length == 0; } _ZNK3glz10fast_float6bigint4hi64ERb: 3418| 4.05k| GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept { 3419| 4.05k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3420| 4.05k| if (vec.len() == 0) { ------------------ | Branch (3420:9): [True: 0, False: 4.05k] ------------------ 3421| 0| return empty_hi64(truncated); 3422| 4.05k| } else if (vec.len() == 1) { ------------------ | Branch (3422:16): [True: 830, False: 3.22k] ------------------ 3423| 830| return uint64_hi64(vec.rindex(0), truncated); 3424| 3.22k| } else { 3425| 3.22k| uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated); 3426| 3.22k| truncated |= vec.nonzero(2); 3427| 3.22k| return result; 3428| 3.22k| } 3429| |#else 3430| | if (vec.len() == 0) { 3431| | return empty_hi64(truncated); 3432| | } else if (vec.len() == 1) { 3433| | return uint32_hi64(vec.rindex(0), truncated); 3434| | } else if (vec.len() == 2) { 3435| | return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated); 3436| | } else { 3437| | uint64_t result = 3438| | uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated); 3439| | truncated |= vec.nonzero(3); 3440| | return result; 3441| | } 3442| |#endif 3443| 4.05k| } _ZN3glz10fast_float11uint64_hi64EmRb: 3132| 830|uint64_hi64(uint64_t r0, bool &truncated) noexcept { 3133| 830| truncated = false; 3134| 830| int shl = leading_zeroes(r0); 3135| 830| return r0 << shl; 3136| 830|} _ZN3glz10fast_float11uint64_hi64EmmRb: 3139| 3.22k|uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept { 3140| 3.22k| int shl = leading_zeroes(r0); 3141| 3.22k| if (shl == 0) { ------------------ | Branch (3141:7): [True: 295, False: 2.93k] ------------------ 3142| 295| truncated = r1 != 0; 3143| 295| return r0; 3144| 2.93k| } else { 3145| 2.93k| int shr = 64 - shl; 3146| 2.93k| truncated = (r1 << shl) != 0; 3147| 2.93k| return (r0 << shl) | (r1 >> shr); 3148| 2.93k| } 3149| 3.22k|} _ZNK3glz10fast_float8stackvecILt62EE7nonzeroEm: 3107| 3.22k| GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept { 3108| 3.22k| while (index < len()) { ------------------ | Branch (3108:12): [True: 1.91k, False: 1.31k] ------------------ 3109| 1.91k| if (rindex(index) != 0) { ------------------ | Branch (3109:11): [True: 1.91k, False: 3] ------------------ 3110| 1.91k| return true; 3111| 1.91k| } 3112| 3| index++; 3113| 3| } 3114| 1.31k| return false; 3115| 3.22k| } _ZNK3glz10fast_float6bigint10bit_lengthEv: 3547| 4.05k| GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept { 3548| 4.05k| int lz = ctlz(); 3549| 4.05k| return int(limb_bits * vec.len()) - lz; 3550| 4.05k| } _ZNK3glz10fast_float6bigint4ctlzEv: 3532| 4.05k| GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept { 3533| 4.05k| if (vec.is_empty()) { ------------------ | Branch (3533:9): [True: 0, False: 4.05k] ------------------ 3534| 0| return 0; 3535| 4.05k| } else { 3536| 4.05k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3537| 4.05k| return leading_zeroes(vec.rindex(0)); 3538| |#else 3539| | // no use defining a specialized leading_zeroes for a 32-bit type. 3540| | uint64_t r0 = vec.rindex(0); 3541| | return leading_zeroes(r0 << 32); 3542| |#endif 3543| 4.05k| } 3544| 4.05k| } _ZN3glz10fast_float5roundIdZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiEUlRS3_iE_EEvS6_T0_: 3707| 4.05k| callback cb) noexcept { 3708| 4.05k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 4.05k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 0, False: 4.05k] ------------------ 3710| | // have a denormal float 3711| 0| int32_t shift = -am.power2 + 1; 3712| 0| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 0| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 0, False: 0] ------------------ 3715| 0| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 0| ? 0 3717| 0| : 1; 3718| 0| return; 3719| 0| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 4.05k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 4.05k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 201, False: 3.85k] ------------------ 3726| 4.05k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 201| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 201| am.power2++; 3729| 201| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 4.05k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 4.05k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 4.05k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 4.05k|} _ZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_i: 3951| 4.05k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 4.05k| round_nearest_tie_even( 3953| 4.05k| a, shift, 3954| 4.05k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 4.05k| return is_above || (is_halfway && truncated) || 3956| 4.05k| (is_odd && is_halfway); 3957| 4.05k| }); 3958| 4.05k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS3_iE_clES6_iEUlbbbE_EEvS6_iT_: 3742| 4.05k| callback cb) noexcept { 3743| 4.05k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 4.05k] ------------------ 3744| 4.05k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 4.05k] ------------------ 3745| 4.05k| uint64_t truncated_bits = am.mantissa & mask; 3746| 4.05k| bool is_above = truncated_bits > halfway; 3747| 4.05k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 4.05k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 4.05k] ------------------ 3751| 0| am.mantissa = 0; 3752| 4.05k| } else { 3753| 4.05k| am.mantissa >>= shift; 3754| 4.05k| } 3755| 4.05k| am.power2 += shift; 3756| | 3757| 4.05k| bool is_odd = (am.mantissa & 1) == 1; 3758| 4.05k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 4.05k|} _ZZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_iENKUlbbbE_clEbbb: 3954| 4.05k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 4.05k| return is_above || (is_halfway && truncated) || ------------------ | Branch (3955:18): [True: 919, False: 3.13k] | Branch (3955:31): [True: 641, False: 2.49k] | Branch (3955:45): [True: 398, False: 243] ------------------ 3956| 2.73k| (is_odd && is_halfway); ------------------ | Branch (3956:19): [True: 494, False: 2.24k] | Branch (3956:29): [True: 9, False: 485] ------------------ 3957| 4.05k| }); _ZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_i: 3970| 13.3k| bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept { 3971| 13.3k| bigint &real_digits = bigmant; 3972| 13.3k| int32_t real_exp = exponent; 3973| | 3974| | // get the value of `b`, rounded down, and get a bigint representation of b+h 3975| 13.3k| adjusted_mantissa am_b = am; 3976| | // gcc7 buf: use a lambda to remove the noexcept qualifier bug with 3977| | // -Wnoexcept-type. 3978| 13.3k| round(am_b, 3979| 13.3k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); 3980| 13.3k| T b; 3981| 13.3k| to_float(false, am_b, b); 3982| 13.3k| adjusted_mantissa theor = to_extended_halfway(b); 3983| 13.3k| bigint theor_digits(theor.mantissa); 3984| 13.3k| int32_t theor_exp = theor.power2; 3985| | 3986| | // scale real digits and theor digits to be same power. 3987| 13.3k| int32_t pow2_exp = theor_exp - real_exp; 3988| 13.3k| uint32_t pow5_exp = uint32_t(-real_exp); 3989| 13.3k| if (pow5_exp != 0) { ------------------ | Branch (3989:7): [True: 13.3k, False: 0] ------------------ 3990| 13.3k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp)); ------------------ | | 344| 13.3k| { ((void)(x)); } ------------------ 3991| 13.3k| } 3992| 13.3k| if (pow2_exp > 0) { ------------------ | Branch (3992:7): [True: 10.0k, False: 3.30k] ------------------ 3993| 10.0k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp))); ------------------ | | 344| 10.0k| { ((void)(x)); } ------------------ 3994| 10.0k| } else if (pow2_exp < 0) { ------------------ | Branch (3994:14): [True: 3.10k, False: 196] ------------------ 3995| 3.10k| GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp))); ------------------ | | 344| 3.10k| { ((void)(x)); } ------------------ 3996| 3.10k| } 3997| | 3998| | // compare digits, and use it to director rounding 3999| 13.3k| int ord = real_digits.compare(theor_digits); 4000| 13.3k| adjusted_mantissa answer = am; 4001| 13.3k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 13.3k| round_nearest_tie_even( 4003| 13.3k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 13.3k| (void)_; // not needed, since we've done our comparison 4005| 13.3k| (void)__; // not needed, since we've done our comparison 4006| 13.3k| if (ord > 0) { 4007| 13.3k| return true; 4008| 13.3k| } else if (ord < 0) { 4009| 13.3k| return false; 4010| 13.3k| } else { 4011| 13.3k| return is_odd; 4012| 13.3k| } 4013| 13.3k| }); 4014| 13.3k| }); 4015| | 4016| 13.3k| return answer; 4017| 13.3k|} _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE_EEvS6_T0_: 3707| 13.3k| callback cb) noexcept { 3708| 13.3k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 13.3k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 731, False: 12.6k] ------------------ 3710| | // have a denormal float 3711| 731| int32_t shift = -am.power2 + 1; 3712| 731| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 731| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 731, False: 0] ------------------ 3715| 731| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 731| ? 0 3717| 731| : 1; 3718| 731| return; 3719| 731| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 12.6k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 12.6k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 0, False: 12.6k] ------------------ 3726| 12.6k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 0| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 0| am.power2++; 3729| 0| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 12.6k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 12.6k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 12.6k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 12.6k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE_clES5_i: 3979| 13.3k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); _ZN3glz10fast_float10round_downERNS0_17adjusted_mantissaEi: 3762| 13.3k|round_down(adjusted_mantissa &am, int32_t shift) noexcept { 3763| 13.3k| if (shift == 64) { ------------------ | Branch (3763:7): [True: 0, False: 13.3k] ------------------ 3764| 0| am.mantissa = 0; 3765| 13.3k| } else { 3766| 13.3k| am.mantissa >>= shift; 3767| 13.3k| } 3768| 13.3k| am.power2 += shift; 3769| 13.3k|} _ZN3glz10fast_float19to_extended_halfwayIdEENS0_17adjusted_mantissaET_: 3696| 13.3k|to_extended_halfway(T value) noexcept { 3697| 13.3k| adjusted_mantissa am = to_extended(value); 3698| 13.3k| am.mantissa <<= 1; 3699| 13.3k| am.mantissa += 1; 3700| 13.3k| am.power2 -= 1; 3701| 13.3k| return am; 3702| 13.3k|} _ZN3glz10fast_float11to_extendedIdEENS0_17adjusted_mantissaET_: 3661| 13.3k|to_extended(T value) noexcept { 3662| 13.3k| using equiv_uint = equiv_uint_t; 3663| 13.3k| constexpr equiv_uint exponent_mask = binary_format::exponent_mask(); 3664| 13.3k| constexpr equiv_uint mantissa_mask = binary_format::mantissa_mask(); 3665| 13.3k| constexpr equiv_uint hidden_bit_mask = binary_format::hidden_bit_mask(); 3666| | 3667| 13.3k| adjusted_mantissa am; 3668| 13.3k| int32_t bias = binary_format::mantissa_explicit_bits() - 3669| 13.3k| binary_format::minimum_exponent(); 3670| 13.3k| equiv_uint bits; 3671| 13.3k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 3672| 13.3k| bits = std::bit_cast(value); 3673| |#else 3674| | ::memcpy(&bits, &value, sizeof(T)); 3675| |#endif 3676| 13.3k| if ((bits & exponent_mask) == 0) { ------------------ | Branch (3676:7): [True: 731, False: 12.6k] ------------------ 3677| | // denormal 3678| 731| am.power2 = 1 - bias; 3679| 731| am.mantissa = bits & mantissa_mask; 3680| 12.6k| } else { 3681| | // normal 3682| 12.6k| am.power2 = int32_t((bits & exponent_mask) >> 3683| 12.6k| binary_format::mantissa_explicit_bits()); 3684| 12.6k| am.power2 -= bias; 3685| 12.6k| am.mantissa = (bits & mantissa_mask) | hidden_bit_mask; 3686| 12.6k| } 3687| | 3688| 13.3k| return am; 3689| 13.3k|} _ZN3glz10fast_float6bigintC2Em: 3406| 13.3k| GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() { 3407| 13.3k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3408| 13.3k| vec.push_unchecked(value); 3409| |#else 3410| | vec.push_unchecked(uint32_t(value)); 3411| | vec.push_unchecked(uint32_t(value >> 32)); 3412| |#endif 3413| 13.3k| vec.normalize(); 3414| 13.3k| } _ZNK3glz10fast_float6bigint7compareERKS1_: 3451| 13.3k| GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept { 3452| 13.3k| if (vec.len() > other.vec.len()) { ------------------ | Branch (3452:9): [True: 0, False: 13.3k] ------------------ 3453| 0| return 1; 3454| 13.3k| } else if (vec.len() < other.vec.len()) { ------------------ | Branch (3454:16): [True: 0, False: 13.3k] ------------------ 3455| 0| return -1; 3456| 13.3k| } else { 3457| 73.8k| for (size_t index = vec.len(); index > 0; index--) { ------------------ | Branch (3457:38): [True: 73.1k, False: 701] ------------------ 3458| 73.1k| limb xi = vec[index - 1]; 3459| 73.1k| limb yi = other.vec[index - 1]; 3460| 73.1k| if (xi > yi) { ------------------ | Branch (3460:13): [True: 8.28k, False: 64.8k] ------------------ 3461| 8.28k| return 1; 3462| 64.8k| } else if (xi < yi) { ------------------ | Branch (3462:20): [True: 4.39k, False: 60.4k] ------------------ 3463| 4.39k| return -1; 3464| 4.39k| } 3465| 73.1k| } 3466| 701| return 0; 3467| 13.3k| } 3468| 13.3k| } _ZNK3glz10fast_float8stackvecILt62EEixEm: 3022| 146k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept { 3023| 146k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 146k| { ((void)(x)); } ------------------ 3024| 146k| return data[index]; 3025| 146k| } _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE0_EEvS6_T0_: 3707| 13.3k| callback cb) noexcept { 3708| 13.3k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 13.3k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 731, False: 12.6k] ------------------ 3710| | // have a denormal float 3711| 731| int32_t shift = -am.power2 + 1; 3712| 731| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 731| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 731, False: 0] ------------------ 3715| 731| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 731| ? 0 3717| 731| : 1; 3718| 731| return; 3719| 731| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 12.6k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 12.6k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 400, False: 12.2k] ------------------ 3726| 12.6k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 400| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 400| am.power2++; 3729| 400| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 12.6k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 12.6k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 12.6k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 12.6k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_i: 4001| 13.3k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 13.3k| round_nearest_tie_even( 4003| 13.3k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 13.3k| (void)_; // not needed, since we've done our comparison 4005| 13.3k| (void)__; // not needed, since we've done our comparison 4006| 13.3k| if (ord > 0) { 4007| 13.3k| return true; 4008| 13.3k| } else if (ord < 0) { 4009| 13.3k| return false; 4010| 13.3k| } else { 4011| 13.3k| return is_odd; 4012| 13.3k| } 4013| 13.3k| }); 4014| 13.3k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iENKUlRS3_iE0_clES6_iEUlbbbE_EEvS6_iT_: 3742| 13.3k| callback cb) noexcept { 3743| 13.3k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 13.3k] ------------------ 3744| 13.3k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 13.3k] ------------------ 3745| 13.3k| uint64_t truncated_bits = am.mantissa & mask; 3746| 13.3k| bool is_above = truncated_bits > halfway; 3747| 13.3k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 13.3k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 13.3k] ------------------ 3751| 0| am.mantissa = 0; 3752| 13.3k| } else { 3753| 13.3k| am.mantissa >>= shift; 3754| 13.3k| } 3755| 13.3k| am.power2 += shift; 3756| | 3757| 13.3k| bool is_odd = (am.mantissa & 1) == 1; 3758| 13.3k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 13.3k|} _ZZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_iENKUlbbbE_clEbbb: 4003| 13.3k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 13.3k| (void)_; // not needed, since we've done our comparison 4005| 13.3k| (void)__; // not needed, since we've done our comparison 4006| 13.3k| if (ord > 0) { ------------------ | Branch (4006:15): [True: 8.28k, False: 5.09k] ------------------ 4007| 8.28k| return true; 4008| 8.28k| } else if (ord < 0) { ------------------ | Branch (4008:22): [True: 4.39k, False: 701] ------------------ 4009| 4.39k| return false; 4010| 4.39k| } else { 4011| 701| return is_odd; 4012| 701| } 4013| 13.3k| }); _ZN3glz10fast_float8to_floatIdEEvbNS0_17adjusted_mantissaERT_: 1131| 46.6k|to_float(bool negative, adjusted_mantissa am, T &value) { 1132| 46.6k| using equiv_uint = equiv_uint_t; 1133| 46.6k| equiv_uint word = equiv_uint(am.mantissa); 1134| 46.6k| word = equiv_uint(word | equiv_uint(am.power2) 1135| 46.6k| << binary_format::mantissa_explicit_bits()); 1136| 46.6k| word = 1137| 46.6k| equiv_uint(word | equiv_uint(negative) << binary_format::sign_index()); 1138| 46.6k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 1139| 46.6k| value = std::bit_cast(word); 1140| |#else 1141| | ::memcpy(&value, &word, sizeof(T)); 1142| |#endif 1143| 46.6k|} _ZN3glz10fast_float13binary_formatIdE10sign_indexEv: 758| 46.6k|template <> inline constexpr int binary_format::sign_index() { 759| 46.6k| return 63; 760| 46.6k|} _ZN3glz10fast_float13binary_formatIdE14infinite_powerEv: 750| 118k|template <> inline constexpr int binary_format::infinite_power() { 751| 118k| return 0x7FF; 752| 118k|} jsonrpc_registry.cpp:_ZN3glz8for_eachILm4EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 24| 66.7k| { 25| 66.7k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| 66.7k| else if constexpr (N == 4) { 41| 66.7k| lambda.template operator()<0>(); 42| 66.7k| lambda.template operator()<1>(); 43| 66.7k| lambda.template operator()<2>(); 44| 66.7k| lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 66.7k| } 52| 66.7k| } _ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES3_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSK_: 24| 158| { 25| 158| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 158| else if constexpr (N == 2) { 32| 158| lambda.template operator()<0>(); 33| 158| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 158| } 52| 158| } _ZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m: 81| 27.7k| { 82| 27.7k| if constexpr (N > 0) { 83| | // Explicit sizes for small N to help the compiler and make debugging easier 84| | if constexpr (N == 1) { 85| | (void)index; 86| | (void)(lambda.template operator()<0>()); 87| | } 88| | else if constexpr (N == 2) { 89| | switch (index) { 90| | case 0: 91| | lambda.template operator()<0>(); 92| | break; 93| | case 1: 94| | lambda.template operator()<1>(); 95| | break; 96| | default: 97| | std::unreachable(); 98| | } 99| | } 100| | else if constexpr (N == 3) { 101| | switch (index) { 102| | case 0: 103| | lambda.template operator()<0>(); 104| | break; 105| | case 1: 106| | lambda.template operator()<1>(); 107| | break; 108| | case 2: 109| | lambda.template operator()<2>(); 110| | break; 111| | default: 112| | std::unreachable(); 113| | } 114| | } 115| | else if constexpr (N == 4) { 116| | switch (index) { 117| | case 0: 118| | lambda.template operator()<0>(); 119| | break; 120| | case 1: 121| | lambda.template operator()<1>(); 122| | break; 123| | case 2: 124| | lambda.template operator()<2>(); 125| | break; 126| | case 3: 127| | lambda.template operator()<3>(); 128| | break; 129| | default: 130| | std::unreachable(); 131| | } 132| | } 133| | else if constexpr (N == 5) { 134| | switch (index) { 135| | case 0: 136| | lambda.template operator()<0>(); 137| | break; 138| | case 1: 139| | lambda.template operator()<1>(); 140| | break; 141| | case 2: 142| | lambda.template operator()<2>(); 143| | break; 144| | case 3: 145| | lambda.template operator()<3>(); 146| | break; 147| | case 4: 148| | lambda.template operator()<4>(); 149| | break; 150| | default: 151| | std::unreachable(); 152| | } 153| | } 154| | else if constexpr (N == 6) { 155| | switch (index) { 156| | case 0: 157| | lambda.template operator()<0>(); 158| | break; 159| | case 1: 160| | lambda.template operator()<1>(); 161| | break; 162| | case 2: 163| | lambda.template operator()<2>(); 164| | break; 165| | case 3: 166| | lambda.template operator()<3>(); 167| | break; 168| | case 4: 169| | lambda.template operator()<4>(); 170| | break; 171| | case 5: 172| | lambda.template operator()<5>(); 173| | break; 174| | default: 175| | std::unreachable(); 176| | } 177| | } 178| | else if constexpr (N == 7) { 179| | switch (index) { 180| | case 0: 181| | lambda.template operator()<0>(); 182| | break; 183| | case 1: 184| | lambda.template operator()<1>(); 185| | break; 186| | case 2: 187| | lambda.template operator()<2>(); 188| | break; 189| | case 3: 190| | lambda.template operator()<3>(); 191| | break; 192| | case 4: 193| | lambda.template operator()<4>(); 194| | break; 195| | case 5: 196| | lambda.template operator()<5>(); 197| | break; 198| | case 6: 199| | lambda.template operator()<6>(); 200| | break; 201| | default: 202| | std::unreachable(); 203| | } 204| | } 205| | else if constexpr (N == 8) { 206| | switch (index) { 207| | case 0: 208| | lambda.template operator()<0>(); 209| | break; 210| | case 1: 211| | lambda.template operator()<1>(); 212| | break; 213| | case 2: 214| | lambda.template operator()<2>(); 215| | break; 216| | case 3: 217| | lambda.template operator()<3>(); 218| | break; 219| | case 4: 220| | lambda.template operator()<4>(); 221| | break; 222| | case 5: 223| | lambda.template operator()<5>(); 224| | break; 225| | case 6: 226| | lambda.template operator()<6>(); 227| | break; 228| | case 7: 229| | lambda.template operator()<7>(); 230| | break; 231| | default: 232| | std::unreachable(); 233| | } 234| | } 235| | else if constexpr (N == 9) { 236| | switch (index) { 237| | case 0: 238| | lambda.template operator()<0>(); 239| | break; 240| | case 1: 241| | lambda.template operator()<1>(); 242| | break; 243| | case 2: 244| | lambda.template operator()<2>(); 245| | break; 246| | case 3: 247| | lambda.template operator()<3>(); 248| | break; 249| | case 4: 250| | lambda.template operator()<4>(); 251| | break; 252| | case 5: 253| | lambda.template operator()<5>(); 254| | break; 255| | case 6: 256| | lambda.template operator()<6>(); 257| | break; 258| | case 7: 259| | lambda.template operator()<7>(); 260| | break; 261| | case 8: 262| | lambda.template operator()<8>(); 263| | break; 264| | default: 265| | std::unreachable(); 266| | } 267| | } 268| | else if constexpr (N == 10) { 269| | switch (index) { 270| | case 0: 271| | lambda.template operator()<0>(); 272| | break; 273| | case 1: 274| | lambda.template operator()<1>(); 275| | break; 276| | case 2: 277| | lambda.template operator()<2>(); 278| | break; 279| | case 3: 280| | lambda.template operator()<3>(); 281| | break; 282| | case 4: 283| | lambda.template operator()<4>(); 284| | break; 285| | case 5: 286| | lambda.template operator()<5>(); 287| | break; 288| | case 6: 289| | lambda.template operator()<6>(); 290| | break; 291| | case 7: 292| | lambda.template operator()<7>(); 293| | break; 294| | case 8: 295| | lambda.template operator()<8>(); 296| | break; 297| | case 9: 298| | lambda.template operator()<9>(); 299| | break; 300| | default: 301| | std::unreachable(); 302| | } 303| | } 304| 27.7k| else { 305| |#ifdef _MSC_VER 306| | using Lambda = std::decay_t; 307| | static const auto jump_table = [](std::index_sequence) { 308| | return std::array{make_jump_function()...}; 309| | }(std::make_index_sequence{}); 310| |#else 311| 27.7k| static constexpr auto jump_table = [](std::index_sequence) { 312| 27.7k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; 313| 27.7k| }(std::make_index_sequence{}); 314| 27.7k|#endif 315| | 316| 27.7k|#if defined(__clang_major__) && (__clang_major__ >= 19) 317| 27.7k| [[assume(index < N)]]; 318| 27.7k|#endif 319| 27.7k| jump_table[index](lambda); 320| | 321| | // This code runs significantly slower on Clang 322| | // Simple tests with assembly show that this should be faster, 323| | // but full Glaze assembly need to be looked into 324| | /*[&, index](std::index_sequence) { 325| | (void)((index == I ? lambda.template operator()() : void()), ...); 326| | }(std::make_index_sequence{});*/ 327| 27.7k| } 328| 27.7k| } 329| 27.7k| } _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E_clESU_: 312| 13.9k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E0_clESU_: 312| 286| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E1_clESU_: 312| 755| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E2_clESU_: 312| 896| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E3_clESU_: 312| 6.95k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E4_clESU_: 312| 1.20k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E5_clESU_: 312| 1.44k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E6_clESU_: 312| 1.23k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZN3glz8for_eachILm2EZNS_28process_variant_alternativesINSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSC_TkNS_10is_contextERNS_7contextERPKcSL_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSO_: 24| 1.61k| { 25| 1.61k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 1.61k| else if constexpr (N == 2) { 32| 1.61k| lambda.template operator()<0>(); 33| 1.61k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 1.61k| } 52| 1.61k| } _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E7_clESU_: 312| 413| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E8_clESU_: 312| 287| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E9_clESU_: 312| 100| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E10_clESU_: 312| 80| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E11_clESU_: 312| 163| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZN3glz8for_eachILm13EZNS_2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 50| { 25| 50| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 50| else { 47| 50| [&](std::index_sequence) { 48| 50| (void)(lambda.template operator()(), ...); 49| 50| }(std::make_index_sequence{}); 50| 50| } 51| 50| } 52| 50| } _ZZN3glz8for_eachILm13EZNS_2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_ENKUlTpTnmNS8_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSU_: 47| 50| [&](std::index_sequence) { 48| 50| (void)(lambda.template operator()(), ...); 49| 50| }(std::make_index_sequence{}); _ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 297| { 25| 297| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 297| else if constexpr (N == 2) { 32| 297| lambda.template operator()<0>(); 33| 297| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 297| } 52| 297| } _ZN3glz8for_eachILm2EZNS_2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 123| { 25| 123| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 123| else if constexpr (N == 2) { 32| 123| lambda.template operator()<0>(); 33| 123| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 123| } 52| 123| } jsonrpc_registry.cpp:_ZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 24| 66.7k| { 25| 66.7k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 66.7k| else { 47| 66.7k| [&](std::index_sequence) { 48| 66.7k| (void)(lambda.template operator()(), ...); 49| 66.7k| }(std::make_index_sequence{}); 50| 66.7k| } 51| 66.7k| } 52| 66.7k| } jsonrpc_registry.cpp:_ZZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_ENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSF_: 47| 66.7k| [&](std::index_sequence) { 48| 66.7k| (void)(lambda.template operator()(), ...); 49| 66.7k| }(std::make_index_sequence{}); jsonrpc_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz5pointEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_: 24| 66.7k| { 25| 66.7k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 66.7k| else if constexpr (N == 2) { 32| 66.7k| lambda.template operator()<0>(); 33| 66.7k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 66.7k| } 52| 66.7k| } jsonrpc_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz6nestedEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_: 24| 66.7k| { 25| 66.7k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 66.7k| else if constexpr (N == 2) { 32| 66.7k| lambda.template operator()<0>(); 33| 66.7k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 66.7k| } 52| 66.7k| } _ZN3glz5visitILm4EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m: 81| 249k| { 82| 249k| if constexpr (N > 0) { 83| | // Explicit sizes for small N to help the compiler and make debugging easier 84| | if constexpr (N == 1) { 85| | (void)index; 86| | (void)(lambda.template operator()<0>()); 87| | } 88| | else if constexpr (N == 2) { 89| | switch (index) { 90| | case 0: 91| | lambda.template operator()<0>(); 92| | break; 93| | case 1: 94| | lambda.template operator()<1>(); 95| | break; 96| | default: 97| | std::unreachable(); 98| | } 99| | } 100| | else if constexpr (N == 3) { 101| | switch (index) { 102| | case 0: 103| | lambda.template operator()<0>(); 104| | break; 105| | case 1: 106| | lambda.template operator()<1>(); 107| | break; 108| | case 2: 109| | lambda.template operator()<2>(); 110| | break; 111| | default: 112| | std::unreachable(); 113| | } 114| | } 115| 249k| else if constexpr (N == 4) { 116| 249k| switch (index) { 117| 68.4k| case 0: ------------------ | Branch (117:13): [True: 68.4k, False: 180k] ------------------ 118| 68.4k| lambda.template operator()<0>(); 119| 68.4k| break; 120| 56.6k| case 1: ------------------ | Branch (120:13): [True: 56.6k, False: 192k] ------------------ 121| 56.6k| lambda.template operator()<1>(); 122| 56.6k| break; 123| 39.8k| case 2: ------------------ | Branch (123:13): [True: 39.8k, False: 209k] ------------------ 124| 39.8k| lambda.template operator()<2>(); 125| 39.8k| break; 126| 84.4k| case 3: ------------------ | Branch (126:13): [True: 84.4k, False: 164k] ------------------ 127| 84.4k| lambda.template operator()<3>(); 128| 84.4k| break; 129| 0| default: ------------------ | Branch (129:13): [True: 0, False: 249k] ------------------ 130| 0| std::unreachable(); 131| 249k| } 132| | } 133| | else if constexpr (N == 5) { 134| | switch (index) { 135| | case 0: 136| | lambda.template operator()<0>(); 137| | break; 138| | case 1: 139| | lambda.template operator()<1>(); 140| | break; 141| | case 2: 142| | lambda.template operator()<2>(); 143| | break; 144| | case 3: 145| | lambda.template operator()<3>(); 146| | break; 147| | case 4: 148| | lambda.template operator()<4>(); 149| | break; 150| | default: 151| | std::unreachable(); 152| | } 153| | } 154| | else if constexpr (N == 6) { 155| | switch (index) { 156| | case 0: 157| | lambda.template operator()<0>(); 158| | break; 159| | case 1: 160| | lambda.template operator()<1>(); 161| | break; 162| | case 2: 163| | lambda.template operator()<2>(); 164| | break; 165| | case 3: 166| | lambda.template operator()<3>(); 167| | break; 168| | case 4: 169| | lambda.template operator()<4>(); 170| | break; 171| | case 5: 172| | lambda.template operator()<5>(); 173| | break; 174| | default: 175| | std::unreachable(); 176| | } 177| | } 178| | else if constexpr (N == 7) { 179| | switch (index) { 180| | case 0: 181| | lambda.template operator()<0>(); 182| | break; 183| | case 1: 184| | lambda.template operator()<1>(); 185| | break; 186| | case 2: 187| | lambda.template operator()<2>(); 188| | break; 189| | case 3: 190| | lambda.template operator()<3>(); 191| | break; 192| | case 4: 193| | lambda.template operator()<4>(); 194| | break; 195| | case 5: 196| | lambda.template operator()<5>(); 197| | break; 198| | case 6: 199| | lambda.template operator()<6>(); 200| | break; 201| | default: 202| | std::unreachable(); 203| | } 204| | } 205| | else if constexpr (N == 8) { 206| | switch (index) { 207| | case 0: 208| | lambda.template operator()<0>(); 209| | break; 210| | case 1: 211| | lambda.template operator()<1>(); 212| | break; 213| | case 2: 214| | lambda.template operator()<2>(); 215| | break; 216| | case 3: 217| | lambda.template operator()<3>(); 218| | break; 219| | case 4: 220| | lambda.template operator()<4>(); 221| | break; 222| | case 5: 223| | lambda.template operator()<5>(); 224| | break; 225| | case 6: 226| | lambda.template operator()<6>(); 227| | break; 228| | case 7: 229| | lambda.template operator()<7>(); 230| | break; 231| | default: 232| | std::unreachable(); 233| | } 234| | } 235| | else if constexpr (N == 9) { 236| | switch (index) { 237| | case 0: 238| | lambda.template operator()<0>(); 239| | break; 240| | case 1: 241| | lambda.template operator()<1>(); 242| | break; 243| | case 2: 244| | lambda.template operator()<2>(); 245| | break; 246| | case 3: 247| | lambda.template operator()<3>(); 248| | break; 249| | case 4: 250| | lambda.template operator()<4>(); 251| | break; 252| | case 5: 253| | lambda.template operator()<5>(); 254| | break; 255| | case 6: 256| | lambda.template operator()<6>(); 257| | break; 258| | case 7: 259| | lambda.template operator()<7>(); 260| | break; 261| | case 8: 262| | lambda.template operator()<8>(); 263| | break; 264| | default: 265| | std::unreachable(); 266| | } 267| | } 268| | else if constexpr (N == 10) { 269| | switch (index) { 270| | case 0: 271| | lambda.template operator()<0>(); 272| | break; 273| | case 1: 274| | lambda.template operator()<1>(); 275| | break; 276| | case 2: 277| | lambda.template operator()<2>(); 278| | break; 279| | case 3: 280| | lambda.template operator()<3>(); 281| | break; 282| | case 4: 283| | lambda.template operator()<4>(); 284| | break; 285| | case 5: 286| | lambda.template operator()<5>(); 287| | break; 288| | case 6: 289| | lambda.template operator()<6>(); 290| | break; 291| | case 7: 292| | lambda.template operator()<7>(); 293| | break; 294| | case 8: 295| | lambda.template operator()<8>(); 296| | break; 297| | case 9: 298| | lambda.template operator()<9>(); 299| | break; 300| | default: 301| | std::unreachable(); 302| | } 303| | } 304| | else { 305| |#ifdef _MSC_VER 306| | using Lambda = std::decay_t; 307| | static const auto jump_table = [](std::index_sequence) { 308| | return std::array{make_jump_function()...}; 309| | }(std::make_index_sequence{}); 310| |#else 311| | static constexpr auto jump_table = [](std::index_sequence) { 312| | return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; 313| | }(std::make_index_sequence{}); 314| |#endif 315| | 316| |#if defined(__clang_major__) && (__clang_major__ >= 19) 317| | [[assume(index < N)]]; 318| |#endif 319| | jump_table[index](lambda); 320| | 321| | // This code runs significantly slower on Clang 322| | // Simple tests with assembly show that this should be faster, 323| | // but full Glaze assembly need to be looked into 324| | /*[&, index](std::index_sequence) { 325| | (void)((index == I ? lambda.template operator()() : void()), ...); 326| | }(std::make_index_sequence{});*/ 327| | } 328| 249k| } 329| 249k| } _ZN3glz8for_eachILm3EZNS_28process_variant_alternativesINSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSK_: 24| 8.39k| { 25| 8.39k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| 8.39k| else if constexpr (N == 3) { 36| 8.39k| lambda.template operator()<0>(); 37| 8.39k| lambda.template operator()<1>(); 38| 8.39k| lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 8.39k| } 52| 8.39k| } _ZN3glz8for_eachILm3EZNS_28process_variant_alternativesINSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSK_: 24| 72.3k| { 25| 72.3k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| 72.3k| else if constexpr (N == 3) { 36| 72.3k| lambda.template operator()<0>(); 37| 72.3k| lambda.template operator()<1>(); 38| 72.3k| lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 72.3k| } 52| 72.3k| } _ZN3glz8for_eachILm1EZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_EUlTnmvE_EEvOT0_: 24| 112k| { 25| 112k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| 112k| if constexpr (N == 1) { 29| 112k| lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 112k| } 52| 112k| } _ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_: 24| 18.0k| { 25| 18.0k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 18.0k| else { 47| 18.0k| [&](std::index_sequence) { 48| 18.0k| (void)(lambda.template operator()(), ...); 49| 18.0k| }(std::make_index_sequence{}); 50| 18.0k| } 51| 18.0k| } 52| 18.0k| } _ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_: 47| 18.0k| [&](std::index_sequence) { 48| 18.0k| (void)(lambda.template operator()(), ...); 49| 18.0k| }(std::make_index_sequence{}); _ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_: 24| 749k| { 25| 749k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 749k| else { 47| 749k| [&](std::index_sequence) { 48| 749k| (void)(lambda.template operator()(), ...); 49| 749k| }(std::make_index_sequence{}); 50| 749k| } 51| 749k| } 52| 749k| } _ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_: 47| 749k| [&](std::index_sequence) { 48| 749k| (void)(lambda.template operator()(), ...); 49| 749k| }(std::make_index_sequence{}); _ZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_: 24| 266k| { 25| 266k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 266k| else { 47| 266k| [&](std::index_sequence) { 48| 266k| (void)(lambda.template operator()(), ...); 49| 266k| }(std::make_index_sequence{}); 50| 266k| } 51| 266k| } 52| 266k| } _ZZN3glz8for_eachILm6EZNS_28process_variant_alternativesINSt3__17variantIJDndNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbNS2_6vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS7_ISE_EEEENSD_ISE_EEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSI_TkNS_10is_contextERNS_7contextERPKcSR_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSU_ENKUlTpTnmNS2_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5EEEEDaS12_: 47| 266k| [&](std::index_sequence) { 48| 266k| (void)(lambda.template operator()(), ...); 49| 266k| }(std::make_index_sequence{}); _ZN3glz10from_charsILb0EdcEENS_10fast_float19from_chars_result_tIT1_EEPKS3_S6_RT0_: 236| 892k| { 237| 892k| using namespace glz::fast_float; 238| 892k| static_assert(is_supported_float_type(), "only some floating-point types are supported"); 239| 892k| static_assert(is_supported_char_type(), "only char, wchar_t, char16_t and char32_t are supported"); 240| | 241| 892k| parsed_number_string_t pns = glz::parse_number_string(first, last); 242| 892k| if (!pns.valid) [[unlikely]] { ------------------ | Branch (242:11): [True: 1.35k, False: 891k] ------------------ 243| 1.35k| return {.ptr = first, .ec = std::errc::invalid_argument}; 244| 1.35k| } 245| | 246| 891k| return from_chars_advanced(pns, value); 247| 892k| } _ZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_: 18| 892k| { 19| 892k| using namespace glz::fast_float; 20| 892k| static constexpr UC decimal_point = '.'; 21| | 22| 892k| parsed_number_string_t answer; 23| 892k| answer.valid = false; 24| 892k| answer.too_many_digits = false; 25| 892k| answer.negative = (*p == UC('-')); 26| 892k| if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here ------------------ | Branch (26:11): [True: 727k, False: 165k] ------------------ 27| 727k| ++p; 28| | 29| 727k| if constexpr (not null_terminated) { 30| 727k| if (p == pend) [[unlikely]] { ------------------ | Branch (30:17): [True: 3, False: 727k] ------------------ 31| 3| return answer; 32| 3| } 33| 727k| } 34| | 35| 727k| if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer ------------------ | Branch (35:14): [True: 41, False: 727k] ------------------ 36| 41| return answer; 37| 41| } 38| 727k| } 39| 892k| UC const* const start_digits = p; 40| | 41| 892k| uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad) 42| | 43| 892k| uint64_t digit; 44| | if constexpr (null_terminated) { 45| | while ((digit = glz::fast_float::digit_value(*p)) <= 9) { 46| | // a multiplication by 10 is cheaper than an arbitrary integer 47| | // multiplication 48| | i = 10 * i + digit; // might overflow, we will handle the overflow later 49| | ++p; 50| | } 51| | } 52| 892k| else { 53| 6.70M| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (53:17): [True: 6.70M, False: 611] | Branch (53:32): [True: 5.81M, False: 891k] ------------------ 54| | // a multiplication by 10 is cheaper than an arbitrary integer 55| | // multiplication 56| 5.81M| i = 10 * i + digit; // might overflow, we will handle the overflow later 57| 5.81M| ++p; 58| 5.81M| } 59| 892k| } 60| | 61| 892k| UC const* const end_of_integer_part = p; 62| 892k| int64_t digit_count = int64_t(end_of_integer_part - start_digits); 63| 892k| answer.integer = glz::fast_float::span(start_digits, size_t(digit_count)); 64| | 65| | // at least 1 digit in integer part, without leading zeros 66| 892k| if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) { ------------------ | Branch (66:11): [True: 1.23k, False: 891k] | Branch (66:32): [True: 10.0k, False: 881k] | Branch (66:62): [True: 46, False: 10.0k] ------------------ 67| 1.27k| return answer; 68| 1.27k| } 69| | 70| 891k| int64_t exponent = 0; 71| 891k| const bool has_decimal_point = [&] { 72| 891k| if constexpr (null_terminated) { 73| 891k| return (*p == decimal_point); 74| 891k| } 75| 891k| else { 76| 891k| return (p != pend) && (*p == decimal_point); 77| 891k| } 78| 891k| }(); 79| 891k| if (has_decimal_point) { ------------------ | Branch (79:11): [True: 26.5k, False: 864k] ------------------ 80| 26.5k| ++p; 81| 26.5k| UC const* before = p; 82| | // can occur at most twice without overflowing, but let it occur more, since 83| | // for integers with many digits, digit parsing is the primary bottleneck. 84| 26.5k| loop_parse_if_eight_digits(p, pend, i); 85| | 86| | if constexpr (null_terminated) { 87| | while ((digit = glz::fast_float::digit_value(*p)) <= 9) { 88| | ++p; 89| | i = i * 10 + digit; // in rare cases, this will overflow, but that's ok 90| | } 91| | } 92| 26.5k| else { 93| 120k| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (93:20): [True: 119k, False: 1.01k] | Branch (93:35): [True: 94.3k, False: 25.5k] ------------------ 94| 94.3k| ++p; 95| 94.3k| i = i * 10 + digit; // in rare cases, this will overflow, but that's ok 96| 94.3k| } 97| 26.5k| } 98| 26.5k| exponent = before - p; 99| 26.5k| answer.fraction = glz::fast_float::span(before, size_t(p - before)); 100| 26.5k| digit_count -= exponent; 101| 26.5k| } 102| | // at least 1 digit in fractional part 103| 891k| if (has_decimal_point && exponent == 0) { ------------------ | Branch (103:11): [True: 26.5k, False: 864k] | Branch (103:32): [True: 29, False: 26.5k] ------------------ 104| 29| return answer; 105| 29| } 106| | 107| 891k| int64_t exp_number = 0; // explicit exponential part 108| | 109| | if constexpr (null_terminated) { 110| | if ((UC('e') == *p) || (UC('E') == *p)) { 111| | UC const* location_of_e = p; 112| | ++p; 113| | bool neg_exp = false; 114| | if (UC('-') == *p) { 115| | neg_exp = true; 116| | ++p; 117| | } 118| | else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) 119| | ++p; 120| | } 121| | if ((digit = glz::fast_float::digit_value(*p)) > 9) { 122| | // Otherwise, we will be ignoring the 'e'. 123| | p = location_of_e; 124| | } 125| | else { 126| | do { 127| | if (exp_number < 0x10000000) { 128| | exp_number = 10 * exp_number + digit; 129| | } 130| | ++p; 131| | } while ((digit = glz::fast_float::digit_value(*p)) <= 9); 132| | if (neg_exp) { 133| | exp_number = -exp_number; 134| | } 135| | exponent += exp_number; 136| | } 137| | } 138| | } 139| 891k| else { 140| 891k| if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) { ------------------ | Branch (140:14): [True: 889k, False: 1.61k] | Branch (140:30): [True: 3.14k, False: 886k] | Branch (140:49): [True: 6.77k, False: 879k] ------------------ 141| 9.91k| UC const* location_of_e = p; 142| 9.91k| ++p; 143| 9.91k| bool neg_exp = false; 144| 9.91k| if ((p != pend) && (UC('-') == *p)) { ------------------ | Branch (144:17): [True: 9.89k, False: 14] | Branch (144:32): [True: 1.92k, False: 7.97k] ------------------ 145| 1.92k| neg_exp = true; 146| 1.92k| ++p; 147| 1.92k| } 148| 7.98k| else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) ------------------ | Branch (148:22): [True: 7.97k, False: 14] | Branch (148:37): [True: 206, False: 7.76k] ------------------ 149| 206| ++p; 150| 206| } 151| 9.91k| if ((p == pend) || (digit = glz::fast_float::digit_value(*p)) > 9) { ------------------ | Branch (151:17): [True: 22, False: 9.88k] | Branch (151:32): [True: 82, False: 9.80k] ------------------ 152| | // Otherwise, we will be ignoring the 'e'. 153| 104| p = location_of_e; 154| 104| } 155| 9.80k| else { 156| 22.2k| do { 157| 22.2k| if (exp_number < 0x10000000) { ------------------ | Branch (157:23): [True: 21.3k, False: 902] ------------------ 158| 21.3k| exp_number = 10 * exp_number + digit; 159| 21.3k| } 160| 22.2k| ++p; 161| 22.2k| } while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9); ------------------ | Branch (161:25): [True: 21.7k, False: 505] | Branch (161:40): [True: 12.4k, False: 9.30k] ------------------ 162| 9.80k| if (neg_exp) { ------------------ | Branch (162:20): [True: 1.91k, False: 7.89k] ------------------ 163| 1.91k| exp_number = -exp_number; 164| 1.91k| } 165| 9.80k| exponent += exp_number; 166| 9.80k| } 167| 9.91k| } 168| 891k| } 169| | 170| 891k| answer.lastmatch = p; 171| 891k| answer.valid = true; 172| | 173| | // If we frequently had to deal with long strings of digits, 174| | // we could extend our code by using a 128-bit integer instead 175| | // of a 64-bit integer. However, this is uncommon. 176| | // 177| | // We can deal with up to 19 digits. 178| 891k| if (digit_count > 19) { // this is uncommon ------------------ | Branch (178:11): [True: 27.8k, False: 863k] ------------------ 179| | // It is possible that the integer had an overflow. 180| | // We have to handle the case where we have 0.0000somenumber. 181| | // We need to be mindful of the case where we only have zeroes... 182| | // E.g., 0.000000000...000. 183| 27.8k| UC const* start = start_digits; 184| | if constexpr (null_terminated) { 185| | while ((*start == UC('0') || *start == decimal_point)) { 186| | if (*start == UC('0')) { 187| | --digit_count; 188| | } 189| | ++start; 190| | } 191| | } 192| 27.8k| else { 193| 766k| while ((start != pend) && (*start == UC('0') || *start == decimal_point)) { ------------------ | Branch (193:20): [True: 766k, False: 24] | Branch (193:40): [True: 732k, False: 33.5k] | Branch (193:61): [True: 5.74k, False: 27.7k] ------------------ 194| 738k| if (*start == UC('0')) { ------------------ | Branch (194:20): [True: 732k, False: 5.74k] ------------------ 195| 732k| --digit_count; 196| 732k| } 197| 738k| ++start; 198| 738k| } 199| 27.8k| } 200| | 201| 27.8k| if (digit_count > 19) { ------------------ | Branch (201:14): [True: 25.9k, False: 1.83k] ------------------ 202| 25.9k| answer.too_many_digits = true; 203| | // Let us start again, this time, avoiding overflows. 204| | // We don't need to check if is_integer, since we use the 205| | // pre-tokenized spans from above. 206| 25.9k| i = 0; 207| 25.9k| p = answer.integer.ptr; 208| 25.9k| UC const* int_end = p + answer.integer.len(); 209| 25.9k| const uint64_t minimal_nineteen_digit_integer{1000000000000000000}; 210| 380k| while ((i < minimal_nineteen_digit_integer) && (p != int_end)) { ------------------ | Branch (210:20): [True: 365k, False: 15.5k] | Branch (210:60): [True: 354k, False: 10.3k] ------------------ 211| 354k| i = i * 10 + uint64_t(*p - UC('0')); 212| 354k| ++p; 213| 354k| } 214| 25.9k| if (i >= minimal_nineteen_digit_integer) { // We have a big integers ------------------ | Branch (214:17): [True: 15.5k, False: 10.3k] ------------------ 215| 15.5k| exponent = end_of_integer_part - p + exp_number; 216| 15.5k| } 217| 10.3k| else { // We have a value with a fractional component. 218| 10.3k| p = answer.fraction.ptr; 219| 10.3k| UC const* frac_end = p + answer.fraction.len(); 220| 463k| while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) { ------------------ | Branch (220:23): [True: 453k, False: 10.3k] | Branch (220:63): [True: 453k, False: 0] ------------------ 221| 453k| i = i * 10 + uint64_t(*p - UC('0')); 222| 453k| ++p; 223| 453k| } 224| 10.3k| exponent = answer.fraction.ptr - p + exp_number; 225| 10.3k| } 226| | // We have now corrected both exponent and i, to a truncated value 227| 25.9k| } 228| 27.8k| } 229| 891k| answer.exponent = exponent; 230| 891k| answer.mantissa = i; 231| 891k| return answer; 232| 891k| } _ZZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_ENKUlvE_clEv: 71| 891k| const bool has_decimal_point = [&] { 72| | if constexpr (null_terminated) { 73| | return (*p == decimal_point); 74| | } 75| 891k| else { 76| 891k| return (p != pend) && (*p == decimal_point); ------------------ | Branch (76:20): [True: 890k, False: 597] | Branch (76:35): [True: 26.5k, False: 864k] ------------------ 77| 891k| } 78| 891k| }(); _ZN3glz8to_charsImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_: 221| 4.76M| { 222| 4.76M| using namespace itoa_impl; 223| 4.76M| if (val < 100000000) { ------------------ | Branch (223:11): [True: 4.76M, False: 0] ------------------ 224| 4.76M| return u64_len_1_8(buf, uint32_t(val)); 225| 4.76M| } 226| 0| else if (val < 10000000000000000ull) { ------------------ | Branch (226:16): [True: 0, False: 0] ------------------ 227| 0| const uint64_t hgh = div_1e8(val); 228| 0| const uint32_t low = uint32_t(val - hgh * 100000000); 229| 0| buf = u64_len_1_8(buf, uint32_t(hgh)); 230| 0| return u64_len_8(buf, low); 231| 0| } 232| 0| else { 233| 0| const uint64_t tmp = div_1e8(val); 234| 0| const uint32_t low = uint32_t(val - tmp * 100000000); 235| 0| const uint32_t hgh = uint32_t(tmp / 10000); 236| 0| const uint32_t mid = uint32_t(tmp - uint64_t(hgh) * 10000); 237| 0| buf = u64_len_5_8(buf, hgh); 238| 0| buf = u64_len_4(buf, mid); 239| 0| return u64_len_8(buf, low); 240| 0| } 241| 4.76M| } _ZN3glz9itoa_impl11u64_len_1_8EPcj: 157| 4.76M| { 158| 4.76M| if (val < 100) { ------------------ | Branch (158:14): [True: 4.76M, False: 6.86k] ------------------ 159| 4.76M| return u32_2(buf, val); 160| 4.76M| } 161| 6.86k| else if (val < 10000) { ------------------ | Branch (161:19): [True: 5.84k, False: 1.02k] ------------------ 162| 5.84k| return u32_4(buf, val); 163| 5.84k| } 164| 1.02k| else if (val < 1000000) { ------------------ | Branch (164:19): [True: 981, False: 47] ------------------ 165| 981| return u32_6(buf, val); 166| 981| } 167| 47| else { 168| 47| return u32_8(buf, val); 169| 47| } 170| 4.76M| } _ZN3glz9itoa_impl5u32_2EPcj: 74| 4.76M| { 75| 4.76M| const uint32_t lz = val < 10; 76| 4.76M| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 77| 4.76M| return buf + 2 - lz; 78| 4.76M| } _ZN3glz9itoa_impl5u32_4EPcj: 81| 5.84k| { 82| 5.84k| const uint32_t aa = (val * 5243) >> 19; // val / 100 83| 5.84k| const uint32_t lz = aa < 10; 84| 5.84k| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 85| 5.84k| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 86| 5.84k| return buf + 4 - lz; 87| 5.84k| } _ZN3glz9itoa_impl5u32_6EPcj: 90| 981| { 91| 981| const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); // val / 10000 92| 981| const uint32_t bbcc = val - aa * 10000; 93| 981| const uint32_t bb = (bbcc * 5243) >> 19; // bbcc / 100 94| 981| const uint32_t lz = aa < 10; 95| 981| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 96| 981| std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2); 97| 981| std::memcpy(buf + 4 - lz, &digit_pairs[bbcc - bb * 100], 2); 98| 981| return buf + 6 - lz; 99| 981| } _ZN3glz9itoa_impl5u32_8EPcj: 102| 47| { 103| 47| const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40); // val / 10000 104| 47| const uint32_t ccdd = val - aabb * 10000; 105| 47| const uint32_t aa = (aabb * 5243) >> 19; // aabb / 100 106| 47| const uint32_t cc = (ccdd * 5243) >> 19; // ccdd / 100 107| 47| const uint32_t lz = aa < 10; 108| 47| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 109| 47| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 110| 47| std::memcpy(buf + 4 - lz, &digit_pairs[cc], 2); 111| 47| std::memcpy(buf + 6 - lz, &digit_pairs[ccdd - cc * 100], 2); 112| 47| return buf + 8 - lz; 113| 47| } _ZN3glz13to_chars_40kbIlQsr3stdE7same_asIu14__remove_cvrefIT_ElEEEPcS3_S1_: 328| 30.9k| { 329| 30.9k| *buf = '-'; 330| 30.9k| return to_chars_40kb(buf + (val < 0), 331| 30.9k| static_cast((static_cast(val) ^ (val >> 63)) - (val >> 63))); 332| 30.9k| } _ZN3glz13to_chars_40kbImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_: 291| 30.9k| { 292| 30.9k| using namespace itoa_40kb_impl; 293| 30.9k| if (val < 10000) { ------------------ | Branch (293:11): [True: 24.3k, False: 6.54k] ------------------ 294| 24.3k| if (val < 100) ------------------ | Branch (294:14): [True: 23.8k, False: 592] ------------------ 295| 23.8k| return u64_2(buf, val); 296| 592| else 297| 592| return u64_4(buf, val); 298| 24.3k| } 299| 6.54k| else if (val < 100000000) { ------------------ | Branch (299:16): [True: 923, False: 5.62k] ------------------ 300| 923| if (val < 1000000) ------------------ | Branch (300:14): [True: 571, False: 352] ------------------ 301| 571| return u64_6(buf, val); 302| 352| else 303| 352| return u64_8(buf, val); 304| 923| } 305| 5.62k| else if (val < 1000000000000ULL) { ------------------ | Branch (305:16): [True: 985, False: 4.63k] ------------------ 306| 985| if (val < 10000000000ULL) ------------------ | Branch (306:14): [True: 350, False: 635] ------------------ 307| 350| return u64_10(buf, val); 308| 635| else 309| 635| return u64_12(buf, val); 310| 985| } 311| 4.63k| else if (val < 10000000000000000ULL) { ------------------ | Branch (311:16): [True: 801, False: 3.83k] ------------------ 312| 801| if (val < 100000000000000ULL) ------------------ | Branch (312:14): [True: 372, False: 429] ------------------ 313| 372| return u64_14(buf, val); 314| 429| else 315| 429| return u64_16(buf, val); 316| 801| } 317| 3.83k| else if (val < 1000000000000000000ULL) { ------------------ | Branch (317:16): [True: 3.54k, False: 298] ------------------ 318| 3.54k| return u64_18(buf, val); 319| 3.54k| } 320| 298| else { 321| 298| return u64_20(buf, val); 322| 298| } 323| 30.9k| } _ZN3glz14itoa_40kb_impl5u64_2EPcm: 114| 23.8k| { 115| 23.8k| const uint64_t lz = val < 10; 116| 23.8k| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 117| 23.8k| return buf + 2 - lz; 118| 23.8k| } _ZN3glz14itoa_40kb_impl5u64_4EPcm: 121| 592| { 122| 592| const uint64_t aa = (val * 5243ULL) >> 19; 123| 592| const uint64_t lz = val < 1000; 124| 592| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 125| 592| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 126| 592| return buf + 4 - lz; 127| 592| } _ZN3glz14itoa_40kb_impl5u64_6EPcm: 130| 571| { 131| 571| const uint64_t aa = (val * 429497ULL) >> 32; 132| 571| const uint64_t lz = val < 100000; 133| 571| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 134| 571| std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4); 135| 571| return buf + 6 - lz; 136| 571| } _ZN3glz14itoa_40kb_impl5u64_8EPcm: 139| 352| { 140| 352| const uint64_t aabb = (val * 109951163ULL) >> 40; 141| 352| const uint64_t aa = (aabb * 5243ULL) >> 19; 142| 352| const uint64_t lz = val < 10000000; 143| 352| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 144| 352| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 145| 352| std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4); 146| 352| return buf + 8 - lz; 147| 352| } _ZN3glz14itoa_40kb_impl6u64_10EPcm: 150| 350| { 151| 350| const uint64_t high = div_1e8(val); 152| 350| const uint64_t low = val - high * 100000000; 153| 350| const uint64_t lz = high < 10; 154| 350| std::memcpy(buf, char_table + ((high * 2) | lz), 2); 155| 350| const uint64_t aabb = (low * 109951163ULL) >> 40; 156| 350| const uint64_t ccdd = low - aabb * 10000; 157| 350| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 158| 350| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 159| 350| return buf + 10 - lz; 160| 350| } _ZN3glz14itoa_40kb_impl7div_1e8Em: 50| 9.53k| { 51| 9.53k| constexpr __uint128_t multiplier = 0xabcc77118461cefdULL; 52| 9.53k| constexpr uint64_t shift = 90; 53| 9.53k| return static_cast((static_cast<__uint128_t>(value) * multiplier) >> shift); 54| 9.53k| } _ZN3glz14itoa_40kb_impl6u64_12EPcm: 163| 635| { 164| 635| const uint64_t high = div_1e8(val); 165| 635| const uint64_t low = val - high * 100000000; 166| 635| const uint64_t aa = (high * 5243ULL) >> 19; 167| 635| const uint64_t lz = aa < 10; 168| 635| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 169| 635| std::memcpy(buf + 2 - lz, &digit_pairs[high - aa * 100], 2); 170| 635| const uint64_t aabb = (low * 109951163ULL) >> 40; 171| 635| const uint64_t ccdd = low - aabb * 10000; 172| 635| std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4); 173| 635| std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4); 174| 635| return buf + 12 - lz; 175| 635| } _ZN3glz14itoa_40kb_impl6u64_14EPcm: 178| 372| { 179| 372| const uint64_t high = div_1e8(val); 180| 372| const uint64_t low = val - high * 100000000; 181| 372| const uint64_t aa = (high * 429497ULL) >> 32; 182| 372| const uint64_t lz = aa < 10; 183| 372| const uint64_t bbcc = high - aa * 10000; 184| 372| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 185| 372| std::memcpy(buf + 2 - lz, &digit_quads[bbcc], 4); 186| 372| const uint64_t aabb = (low * 109951163ULL) >> 40; 187| 372| const uint64_t ccdd = low - aabb * 10000; 188| 372| std::memcpy(buf + 6 - lz, &digit_quads[aabb], 4); 189| 372| std::memcpy(buf + 10 - lz, &digit_quads[ccdd], 4); 190| 372| return buf + 14 - lz; 191| 372| } _ZN3glz14itoa_40kb_impl6u64_16EPcm: 194| 429| { 195| 429| const uint64_t high = div_1e8(val); 196| 429| const uint64_t low = val - high * 100000000; 197| 429| uint64_t aabb = (high * 109951163ULL) >> 40; 198| 429| uint64_t ccdd = high - aabb * 10000; 199| 429| const uint64_t aa = (aabb * 5243ULL) >> 19; 200| 429| const uint64_t lz = aa < 10; 201| 429| const uint64_t bb = aabb - aa * 100; 202| 429| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 203| 429| std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2); 204| 429| std::memcpy(buf + 4 - lz, &digit_quads[ccdd], 4); 205| 429| aabb = (low * 109951163ULL) >> 40; 206| 429| ccdd = low - aabb * 10000; 207| 429| std::memcpy(buf + 8 - lz, &digit_quads[aabb], 4); 208| 429| std::memcpy(buf + 12 - lz, &digit_quads[ccdd], 4); 209| 429| return buf + 16 - lz; 210| 429| } _ZN3glz14itoa_40kb_impl6u64_18EPcm: 213| 3.54k| { 214| 3.54k| const uint64_t high = div_1e8(val); 215| 3.54k| const uint64_t low = val - high * 100000000; 216| 3.54k| const uint64_t high10 = div_1e8(high); 217| 3.54k| const uint64_t low10 = high - high10 * 100000000; 218| 3.54k| const uint64_t lz = high10 < 10; 219| 3.54k| std::memcpy(buf, char_table + ((high10 * 2) | lz), 2); 220| 3.54k| uint64_t aabb = (low10 * 109951163ULL) >> 40; 221| 3.54k| uint64_t ccdd = low10 - aabb * 10000; 222| 3.54k| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 223| 3.54k| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 224| 3.54k| aabb = (low * 109951163ULL) >> 40; 225| 3.54k| ccdd = low - aabb * 10000; 226| 3.54k| std::memcpy(buf + 10 - lz, &digit_quads[aabb], 4); 227| 3.54k| std::memcpy(buf + 14 - lz, &digit_quads[ccdd], 4); 228| 3.54k| return buf + 18 - lz; 229| 3.54k| } _ZN3glz14itoa_40kb_impl6u64_20EPcm: 232| 298| { 233| 298| const uint64_t high = div_1e8(val); 234| 298| const uint64_t low = val - high * 100000000; 235| 298| const uint64_t high12 = div_1e8(high); 236| 298| const uint64_t low12 = high - high12 * 100000000; 237| 298| const uint64_t aa = (high12 * 5243ULL) >> 19; 238| 298| const uint64_t lz = aa < 10; 239| 298| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 240| 298| std::memcpy(buf + 2 - lz, &digit_pairs[high12 - aa * 100], 2); 241| 298| uint64_t aabb = (low12 * 109951163ULL) >> 40; 242| 298| uint64_t ccdd = low12 - aabb * 10000; 243| 298| std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4); 244| 298| std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4); 245| 298| aabb = (low * 109951163ULL) >> 40; 246| 298| ccdd = low - aabb * 10000; 247| 298| std::memcpy(buf + 12 - lz, &digit_quads[aabb], 4); 248| 298| std::memcpy(buf + 16 - lz, &digit_quads[ccdd], 4); 249| 298| return buf + 20 - lz; 250| 298| } _ZN3glz13to_chars_40kbIiQsr3stdE7same_asIu14__remove_cvrefIT_EiEEEPcS3_S1_: 282| 854| { 283| 854| *buf = '-'; 284| 854| return to_chars_40kb(buf + (val < 0), 285| 854| static_cast((static_cast(val) ^ (val >> 31)) - (val >> 31))); 286| 854| } _ZN3glz13to_chars_40kbIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_: 260| 854| { 261| 854| using namespace itoa_40kb_impl; 262| 854| if (val < 10000) { ------------------ | Branch (262:11): [True: 503, False: 351] ------------------ 263| 503| if (val < 100) ------------------ | Branch (263:14): [True: 418, False: 85] ------------------ 264| 418| return u32_2(buf, val); 265| 85| else 266| 85| return u32_4(buf, val); 267| 503| } 268| 351| else if (val < 100000000) { ------------------ | Branch (268:16): [True: 276, False: 75] ------------------ 269| 276| if (val < 1000000) ------------------ | Branch (269:14): [True: 109, False: 167] ------------------ 270| 109| return u32_6(buf, val); 271| 167| else 272| 167| return u32_8(buf, val); 273| 276| } 274| 75| else { 275| 75| return u32_10(buf, val); 276| 75| } 277| 854| } _ZN3glz14itoa_40kb_impl5u32_2EPcj: 62| 418| { 63| 418| const uint64_t lz = val < 10; 64| | // Use OR since val*2 is always even (bit 0 is 0) 65| 418| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 66| 418| return buf + 2 - lz; 67| 418| } _ZN3glz14itoa_40kb_impl5u32_4EPcj: 70| 85| { 71| 85| const uint32_t aa = (val * 5243) >> 19; 72| 85| const uint64_t lz = val < 1000; 73| 85| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 74| 85| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 75| 85| return buf + 4 - lz; 76| 85| } _ZN3glz14itoa_40kb_impl5u32_6EPcj: 79| 109| { 80| 109| const uint32_t aa = static_cast((static_cast(val) * 429497ULL) >> 32); 81| 109| const uint64_t lz = val < 100000; 82| 109| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 83| 109| std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4); 84| 109| return buf + 6 - lz; 85| 109| } _ZN3glz14itoa_40kb_impl5u32_8EPcj: 88| 167| { 89| 167| const uint64_t aabb = (static_cast(val) * 109951163ULL) >> 40; 90| 167| const uint64_t aa = (aabb * 5243ULL) >> 19; 91| 167| const uint64_t lz = val < 10000000; 92| 167| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 93| 167| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 94| 167| std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4); 95| 167| return buf + 8 - lz; 96| 167| } _ZN3glz14itoa_40kb_impl6u32_10EPcj: 99| 75| { 100| 75| const uint64_t high = div_1e8(val); 101| 75| const uint64_t low = val - high * 100000000; 102| 75| const uint64_t lz = high < 10; 103| 75| std::memcpy(buf, char_table + ((high * 2) | lz), 2); 104| 75| const uint64_t aabb = (low * 109951163ULL) >> 40; 105| 75| const uint64_t ccdd = low - aabb * 10000; 106| 75| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 107| 75| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 108| 75| return buf + 10 - lz; 109| 75| } _ZN3glz7skip_wsIXtlNS_7ws_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEbOT0_OT1_T2_: 622| 25.1M| { 623| 25.1M| using namespace glz::detail; 624| | 625| 25.1M| if constexpr (not Opts.minified) { 626| | if constexpr (Opts.null_terminated) { 627| | if constexpr (Opts.comments) { 628| | while (whitespace_comment_table[uint8_t(*it)]) { 629| | if (*it == '/') [[unlikely]] { 630| | skip_comment(ctx, it, end); 631| | if (bool(ctx.error)) [[unlikely]] { 632| | return true; 633| | } 634| | } 635| | else [[likely]] { 636| | ++it; 637| | } 638| | } 639| | } 640| | else { 641| | while (whitespace_table[uint8_t(*it)]) { 642| | ++it; 643| | } 644| | } 645| | } 646| 25.1M| else { 647| | if constexpr (Opts.comments) { 648| | while (it < end && whitespace_comment_table[uint8_t(*it)]) { 649| | if (*it == '/') [[unlikely]] { 650| | skip_comment(ctx, it, end); 651| | if (bool(ctx.error)) [[unlikely]] { 652| | return true; 653| | } 654| | } 655| | else [[likely]] { 656| | ++it; 657| | } 658| | } 659| | if (it == end) [[unlikely]] { 660| | ctx.error = error_code::end_reached; 661| | return true; 662| | } 663| | } 664| 25.1M| else { 665| 76.8M| while (it < end && whitespace_table[uint8_t(*it)]) { ------------------ | Branch (665:23): [True: 76.8M, False: 1.28k] | Branch (665:35): [True: 51.7M, False: 25.1M] ------------------ 666| 51.7M| ++it; 667| 51.7M| } 668| 25.1M| if (it == end) [[unlikely]] { ------------------ | Branch (668:20): [True: 1.28k, False: 25.1M] ------------------ 669| 1.28k| ctx.error = error_code::end_reached; 670| 1.28k| return true; 671| 1.28k| } 672| 25.1M| } 673| 25.1M| } 674| | } 675| | else if constexpr (not Opts.null_terminated) { 676| | // Minified input has no whitespace to skip, but a non-null-terminated buffer can still 677| | // be exhausted at this point. The non-minified branch above performs the same check; a 678| | // null-terminated buffer relies on the trailing sentinel and keeps this a pure no-op. 679| | if (it == end) [[unlikely]] { 680| | ctx.error = error_code::end_reached; 681| | return true; 682| | } 683| | } 684| | 685| 25.1M| return false; 686| 25.1M| } _ZN3glz17match_invalid_endILc123EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 506k| { 412| 506k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 328k, False: 178k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| 328k| else if constexpr (C == '{' || C == '}') { 426| 328k| ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 328k| return true; 432| 328k| } 433| 178k| else [[likely]] { 434| 178k| ++it; 435| 178k| } 436| 178k| if constexpr (not Opts.null_terminated) { 437| 178k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 2, False: 178k] ------------------ 438| 2| ctx.error = error_code::unexpected_end; 439| 2| return true; 440| 2| } 441| 178k| } 442| 178k| return false; 443| 506k| } _ZN3glz17match_invalid_endILc44EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 1.21M| { 412| 1.21M| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 8.95k, False: 1.20M] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| 8.95k| else if constexpr (C == ',') { 417| 8.95k| ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 8.95k| return true; 432| 8.95k| } 433| 1.20M| else [[likely]] { 434| 1.20M| ++it; 435| 1.20M| } 436| 1.20M| if constexpr (not Opts.null_terminated) { 437| 1.20M| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 1, False: 1.20M] ------------------ 438| 1| ctx.error = error_code::unexpected_end; 439| 1| return true; 440| 1| } 441| 1.20M| } 442| 1.20M| return false; 443| 1.21M| } _ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m: 689| 1.05M| { 690| 1.05M| if (length > 7) { ------------------ | Branch (690:11): [True: 659k, False: 391k] ------------------ 691| 659k| uint64_t v[2]; 692| 674k| while (length > 8) { ------------------ | Branch (692:17): [True: 143k, False: 531k] ------------------ 693| 143k| std::memcpy(v, ws, 8); 694| 143k| std::memcpy(v + 1, it, 8); 695| 143k| if (v[0] != v[1]) { ------------------ | Branch (695:17): [True: 127k, False: 15.8k] ------------------ 696| 127k| return; 697| 127k| } 698| 15.8k| length -= 8; 699| 15.8k| ws += 8; 700| 15.8k| it += 8; 701| 15.8k| } 702| | 703| 531k| const auto shift = 8 - length; 704| 531k| ws -= shift; 705| 531k| it -= shift; 706| | 707| 531k| std::memcpy(v, ws, 8); 708| 531k| std::memcpy(v + 1, it, 8); 709| 531k| if (v[0] != v[1]) { ------------------ | Branch (709:14): [True: 525k, False: 5.43k] ------------------ 710| 525k| return; 711| 525k| } 712| 5.43k| it += 8; 713| 5.43k| return; 714| 531k| } 715| 391k| { 716| 391k| constexpr uint64_t n{sizeof(uint32_t)}; 717| 391k| if (length >= n) { ------------------ | Branch (717:14): [True: 229k, False: 162k] ------------------ 718| 229k| uint32_t v[2]; 719| 229k| std::memcpy(v, ws, n); 720| 229k| std::memcpy(v + 1, it, n); 721| 229k| if (v[0] != v[1]) { ------------------ | Branch (721:17): [True: 223k, False: 6.08k] ------------------ 722| 223k| return; 723| 223k| } 724| 6.08k| length -= n; 725| 6.08k| ws += n; 726| 6.08k| it += n; 727| 6.08k| } 728| 391k| } 729| 168k| { 730| 168k| constexpr uint64_t n{sizeof(uint16_t)}; 731| 168k| if (length >= n) { ------------------ | Branch (731:14): [True: 94.8k, False: 73.5k] ------------------ 732| 94.8k| uint16_t v[2]; 733| 94.8k| std::memcpy(v, ws, n); 734| 94.8k| std::memcpy(v + 1, it, n); 735| 94.8k| if (v[0] != v[1]) { ------------------ | Branch (735:17): [True: 89.7k, False: 5.10k] ------------------ 736| 89.7k| return; 737| 89.7k| } 738| | // length -= n; 739| | // ws += n; 740| 5.10k| it += n; 741| 5.10k| } 742| 168k| } 743| | // We have to call a whitespace check after this function 744| | // in case the whitespace is mismatching. 745| | // So, we forgo this check as to not duplicate. 746| | /*if (length && *ws == *it) { 747| | ++it; 748| | }*/ 749| 168k| } _ZN3glz17match_invalid_endILc58EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 1.96M| { 412| 1.96M| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 11.6k, False: 1.95M] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| 11.6k| else if constexpr (C == ':') { 420| 11.6k| ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 11.6k| return true; 432| 11.6k| } 433| 1.95M| else [[likely]] { 434| 1.95M| ++it; 435| 1.95M| } 436| 1.95M| if constexpr (not Opts.null_terminated) { 437| 1.95M| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 11, False: 1.95M] ------------------ 438| 11| ctx.error = error_code::unexpected_end; 439| 11| return true; 440| 11| } 441| 1.95M| } 442| 1.95M| return false; 443| 1.96M| } _ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb0ELb1EEELc123ELc125ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QaantdtT_6paddedntdtT_8commentsEEvOT3_OT4_T5_: 1235| 151k| { 1236| 151k| static constexpr bool opening_not_handled = false; 1237| 151k| static constexpr bool skip_validation = false; 1238| | // skip_validation routes skip_string through the end-bounded skip_string_view path, which 1239| | // stops on `end` rather than on a sentinel, so this flag has no effect from here. 1240| 151k| static constexpr bool null_terminated_unused = true; 1241| | 1242| 151k| size_t depth = Depth; 1243| | 1244| 27.6M| for (const auto fin = end - 7; it < fin;) { ------------------ | Branch (1244:38): [True: 27.6M, False: 18.6k] ------------------ 1245| 27.6M| uint64_t chunk; 1246| 27.6M| std::memcpy(&chunk, it, 8); 1247| | if constexpr (std::endian::native == std::endian::big) { 1248| | chunk = std::byteswap(chunk); 1249| | } 1250| 27.6M| const uint64_t test = has_quote(chunk) | has_char(chunk) | has_char(chunk); 1251| 27.6M| if (test) { ------------------ | Branch (1251:14): [True: 3.65M, False: 23.9M] ------------------ 1252| 3.65M| it += (countr_zero(test) >> 3); 1253| | 1254| 3.65M| switch (*it) { 1255| 600k| case '"': { ------------------ | Branch (1255:13): [True: 600k, False: 3.05M] ------------------ 1256| 600k| skip_string(ctx, it, end); 1258| 600k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1258:20): [True: 1.52k, False: 599k] ------------------ 1259| 1.52k| return; 1260| 1.52k| } 1261| 599k| break; 1262| 600k| } 1263| 2.86M| case open: { ------------------ | Branch (1263:13): [True: 2.86M, False: 789k] ------------------ 1264| 2.86M| ++it; 1265| 2.86M| ++depth; 1266| 2.86M| break; 1267| 600k| } 1268| 188k| case close: { ------------------ | Branch (1268:13): [True: 188k, False: 3.46M] ------------------ 1269| 188k| ++it; 1270| 188k| --depth; 1271| 188k| if (depth == 0) { ------------------ | Branch (1271:20): [True: 131k, False: 57.0k] ------------------ 1272| 131k| return; 1273| 131k| } 1274| 57.0k| break; 1275| 188k| } 1276| 57.0k| default: { ------------------ | Branch (1276:13): [True: 0, False: 3.65M] ------------------ 1277| 0| ctx.error = error_code::unexpected_end; 1278| 0| return; 1279| 188k| } 1280| 3.65M| } 1281| 3.65M| } 1282| 23.9M| else { 1283| 23.9M| it += 8; 1284| 23.9M| } 1285| 27.6M| } 1286| | 1287| | // Tail end of buffer. Should be rare we even get here 1288| 30.6k| while (it < end) { ------------------ | Branch (1288:14): [True: 29.9k, False: 677] ------------------ 1289| 29.9k| switch (*it) { 1290| 4.69k| case '"': { ------------------ | Branch (1290:10): [True: 4.69k, False: 25.2k] ------------------ 1291| 4.69k| skip_string(ctx, it, end); 1293| 4.69k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1293:17): [True: 389, False: 4.30k] ------------------ 1294| 389| return; 1295| 389| } 1296| 4.30k| break; 1297| 4.69k| } 1298| 4.30k| case '/': { ------------------ | Branch (1298:10): [True: 109, False: 29.8k] ------------------ 1299| 109| skip_comment(ctx, it, end); 1300| 109| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1300:17): [True: 48, False: 61] ------------------ 1301| 48| return; 1302| 48| } 1303| 61| break; 1304| 109| } 1305| 379| case open: { ------------------ | Branch (1305:10): [True: 379, False: 29.5k] ------------------ 1306| 379| ++it; 1307| 379| ++depth; 1308| 379| break; 1309| 109| } 1310| 18.4k| case close: { ------------------ | Branch (1310:10): [True: 18.4k, False: 11.5k] ------------------ 1311| 18.4k| ++it; 1312| 18.4k| --depth; 1313| 18.4k| if (depth == 0) { ------------------ | Branch (1313:17): [True: 17.5k, False: 925] ------------------ 1314| 17.5k| return; 1315| 17.5k| } 1316| 925| break; 1317| 18.4k| } 1318| 6.32k| default: { ------------------ | Branch (1318:10): [True: 6.32k, False: 23.6k] ------------------ 1319| 6.32k| ++it; 1320| 6.32k| } 1321| 29.9k| } 1322| 29.9k| } 1323| | 1324| 677| ctx.error = error_code::unexpected_end; 1325| 677| } _ZN3glz9has_quoteEm: 534| 57.6M| { 535| 57.6M| return has_zero(chunk ^ repeat_byte8('"')); 536| 57.6M| } _ZN3glz8has_zeroEm: 529| 139M| { 530| 139M| return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u); 531| 139M| } _ZN3glz8has_charILc123EEEDam: 550| 27.6M| { 551| 27.6M| return has_zero(chunk ^ repeat_byte8(Char)); 552| 27.6M| } _ZN3glz8has_charILc125EEEDam: 550| 27.6M| { 551| 27.6M| return has_zero(chunk ^ repeat_byte8(Char)); 552| 27.6M| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_: 1020| 720k| { 1021| 720k| if constexpr (not Opts.opening_handled) { 1022| 720k| ++it; 1023| 720k| } 1024| | 1025| 720k| const auto* const utf8_start = it; 1026| | 1027| | if constexpr (Opts.validate_skipped) { 1028| | while (true) { 1029| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1030| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1031| | // scan before each dereference. 1032| | if constexpr (not Opts.null_terminated) { 1033| | if (it == end) [[unlikely]] { 1034| | ctx.error = error_code::unexpected_end; 1035| | return; 1036| | } 1037| | } 1038| | if ((*it & 0b11100000) == 0) [[unlikely]] { 1039| | ctx.error = error_code::syntax_error; 1040| | return; 1041| | } 1042| | 1043| | switch (*it) { 1044| | case '"': { 1045| | validate_utf8_span(ctx, utf8_start, it); 1046| | ++it; 1047| | return; 1048| | } 1049| | case '\\': { 1050| | ++it; 1051| | if constexpr (not Opts.null_terminated) { 1052| | if (it == end) [[unlikely]] { 1053| | ctx.error = error_code::unexpected_end; 1054| | return; 1055| | } 1056| | } 1057| | if (char_unescape_table[uint8_t(*it)]) { 1058| | ++it; 1059| | continue; 1060| | } 1061| | else if (*it == 'u') { 1062| | ++it; 1063| | if (skip_unicode_code_point(it, end)) [[likely]] { 1064| | continue; 1065| | } 1066| | else [[unlikely]] { 1067| | ctx.error = error_code::unicode_escape_conversion_failure; 1068| | return; 1069| | } 1070| | } 1071| | ctx.error = error_code::syntax_error; 1072| | return; 1073| | } 1074| | } 1075| | ++it; 1076| | } 1077| | } 1078| 720k| else { 1079| 720k| skip_string_view(ctx, it, end); 1080| 720k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1080:14): [True: 1.05k, False: 719k] ------------------ 1081| 1.05k| return; 1082| 1.05k| } 1083| 719k| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1083:14): [True: 1.40k, False: 718k] ------------------ 1084| 1.40k| return; 1085| 1.40k| } 1086| 718k| ++it; // skip the quote 1087| 718k| } 1088| 720k| } _ZN3glz16skip_string_viewITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 863| 898k| { 864| 949k| while (it < end) [[likely]] { ------------------ | Branch (864:14): [True: 949k, False: 55] ------------------ 865| 949k| const auto* pc = std::memchr(it, '"', size_t(end - it)); 866| 949k| if (pc) [[likely]] { ------------------ | Branch (866:14): [True: 948k, False: 1.10k] ------------------ 867| 948k| it = reinterpret_cast>(pc); 868| 948k| auto* prev = it - 1; 869| 1.12M| while (*prev == '\\') { ------------------ | Branch (869:20): [True: 176k, False: 948k] ------------------ 870| 176k| --prev; 871| 176k| } 872| 948k| if (size_t(it - prev) % 2) { ------------------ | Branch (872:17): [True: 896k, False: 51.2k] ------------------ 873| 896k| return; 874| 896k| } 875| 51.2k| ++it; // skip the escaped quote 876| 51.2k| } 877| 1.10k| else [[unlikely]] { 878| 1.10k| break; 879| 1.10k| } 880| 949k| } 881| | 882| 1.16k| ctx.error = error_code::expected_quote; 883| 1.16k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 719k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 719k| else { 840| 719k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 0, False: 719k] ------------------ 841| 0| return false; // pure ASCII is trivially well formed UTF-8 842| 0| } 843| 719k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 1.40k, False: 718k] ------------------ 844| 1.40k| ctx.error = error_code::invalid_utf8; 845| 1.40k| return true; 846| 1.40k| } 847| 718k| return false; 848| 719k| } 849| 719k| } _ZN3glz13validate_utf8IcEEbPKT_m: 801| 1.08M| { 802| 1.08M| const uint8_t* it = reinterpret_cast(str); 803| 1.08M| const uint8_t* const end = it + size; 804| |#if defined(GLZ_UTF8_SIMD) 805| | // 16 is a measured compromise, not a register-size coincidence. The scalar path skips ASCII 8 806| | // bytes at a time, so on ASCII it stays ahead of the vector path's fixed setup cost until the 807| | // input is long enough for the 64 byte ASCII step to engage; on non-ASCII the vector path 808| | // wins from roughly 8 bytes. Raising the threshold buys a few percent on short ASCII and 809| | // costs up to 2.3x on mid length non-ASCII strings, so it stays low. 810| | if (size >= 16) { 811| | return detail::utf8_simd::validate(it, end); 812| | } 813| |#endif 814| 1.08M| return validate_utf8_scalar(it, end); 815| 1.08M| } _ZN3glz20validate_utf8_scalarEPKhS1_: 752| 1.08M| { 753| 39.3M| while (it < end) { ------------------ | Branch (753:14): [True: 38.2M, False: 1.06M] ------------------ 754| | // Optimistic SWAR check for ASCII 755| 38.2M| if (it + 8 <= end) { ------------------ | Branch (755:14): [True: 34.6M, False: 3.57M] ------------------ 756| 34.6M| uint64_t chunk; 757| 34.6M| std::memcpy(&chunk, it, 8); 758| 34.6M| if ((chunk & glz::repeat_byte8(0x80)) == 0) { ------------------ | Branch (758:17): [True: 33.5M, False: 1.14M] ------------------ 759| 33.5M| it += 8; 760| 33.5M| continue; 761| 33.5M| } 762| 34.6M| } 763| | 764| | // Byte-by-byte validation (standard conformant) 765| 4.71M| uint8_t byte = *it; 766| | 767| 4.71M| if (byte < 0x80) { ------------------ | Branch (767:14): [True: 4.39M, False: 323k] ------------------ 768| 4.39M| it++; 769| 4.39M| } 770| 323k| else if ((byte & 0xE0) == 0xC0) { ------------------ | Branch (770:19): [True: 193k, False: 130k] ------------------ 771| | // 2-byte sequence 772| 193k| if (it + 2 > end || (it[1] & 0xC0) != 0x80) return false; ------------------ | Branch (772:17): [True: 55, False: 192k] | Branch (772:33): [True: 3.57k, False: 189k] ------------------ 773| 189k| if (byte < 0xC2) return false; // Overlong ------------------ | Branch (773:17): [True: 188, False: 189k] ------------------ 774| 189k| it += 2; 775| 189k| } 776| 130k| else if ((byte & 0xF0) == 0xE0) { ------------------ | Branch (776:19): [True: 65.2k, False: 65.1k] ------------------ 777| | // 3-byte sequence 778| 65.2k| if (it + 3 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80) return false; ------------------ | Branch (778:17): [True: 69, False: 65.1k] | Branch (778:33): [True: 1.05k, False: 64.0k] | Branch (778:59): [True: 280, False: 63.8k] ------------------ 779| 63.8k| if (byte == 0xE0 && it[1] < 0xA0) return false; // Overlong ------------------ | Branch (779:17): [True: 18.2k, False: 45.6k] | Branch (779:33): [True: 225, False: 17.9k] ------------------ 780| 63.5k| if (byte == 0xED && it[1] >= 0xA0) return false; // Surrogate ------------------ | Branch (780:17): [True: 25.7k, False: 37.8k] | Branch (780:33): [True: 123, False: 25.6k] ------------------ 781| 63.4k| it += 3; 782| 63.4k| } 783| 65.1k| else if ((byte & 0xF8) == 0xF0) { ------------------ | Branch (783:19): [True: 57.1k, False: 8.02k] ------------------ 784| | // 4-byte sequence 785| 57.1k| if (it + 4 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80 || (it[3] & 0xC0) != 0x80) ------------------ | Branch (785:17): [True: 63, False: 57.1k] | Branch (785:33): [True: 1.98k, False: 55.1k] | Branch (785:59): [True: 249, False: 54.8k] | Branch (785:85): [True: 242, False: 54.6k] ------------------ 786| 2.53k| return false; 787| 54.6k| if (byte == 0xF0 && it[1] < 0x90) return false; // Overlong ------------------ | Branch (787:17): [True: 21.0k, False: 33.5k] | Branch (787:33): [True: 190, False: 20.8k] ------------------ 788| 54.4k| if (byte == 0xF4 && it[1] >= 0x90) return false; // > U+10FFFF ------------------ | Branch (788:17): [True: 27.5k, False: 26.8k] | Branch (788:33): [True: 129, False: 27.4k] ------------------ 789| 54.3k| if (byte > 0xF4) return false; // > U+10FFFF ------------------ | Branch (789:17): [True: 132, False: 54.1k] ------------------ 790| 54.1k| it += 4; 791| 54.1k| } 792| 8.02k| else { 793| 8.02k| return false; 794| 8.02k| } 795| 4.71M| } 796| | 797| 1.06M| return true; 798| 1.08M| } _ZN3glz12skip_commentITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 503| 188| { 504| 188| ++it; 505| 188| if (it == end) [[unlikely]] { ------------------ | Branch (505:11): [True: 4, False: 184] ------------------ 506| 4| ctx.error = error_code::unexpected_end; 507| 4| } 508| 184| else if (*it == '/') { ------------------ | Branch (508:16): [True: 46, False: 138] ------------------ 509| 112| while (++it != end && *it != '\n'); ------------------ | Branch (509:17): [True: 76, False: 36] | Branch (509:32): [True: 66, False: 10] ------------------ 510| 46| } 511| 138| else if (*it == '*') { ------------------ | Branch (511:16): [True: 70, False: 68] ------------------ 512| 228| while (++it != end) { ------------------ | Branch (512:17): [True: 165, False: 63] ------------------ 513| 165| if (*it == '*') [[unlikely]] { ------------------ | Branch (513:17): [True: 36, False: 129] ------------------ 514| 36| if (++it == end) [[unlikely]] ------------------ | Branch (514:20): [True: 2, False: 34] ------------------ 515| 2| break; 516| 34| else if (*it == '/') [[likely]] { ------------------ | Branch (516:25): [True: 5, False: 29] ------------------ 517| 5| ++it; 518| 5| break; 519| 5| } 520| 36| } 521| 165| } 522| 70| } 523| 68| else [[unlikely]] { 524| 68| ctx.error = error_code::expected_end_comment; 525| 68| } 526| 188| } _ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb0ELb1EEELc91ELc93ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QaantdtT_6paddedntdtT_8commentsEEvOT3_OT4_T5_: 1235| 17.4k| { 1236| 17.4k| static constexpr bool opening_not_handled = false; 1237| 17.4k| static constexpr bool skip_validation = false; 1238| | // skip_validation routes skip_string through the end-bounded skip_string_view path, which 1239| | // stops on `end` rather than on a sentinel, so this flag has no effect from here. 1240| 17.4k| static constexpr bool null_terminated_unused = true; 1241| | 1242| 17.4k| size_t depth = Depth; 1243| | 1244| 13.2M| for (const auto fin = end - 7; it < fin;) { ------------------ | Branch (1244:38): [True: 13.2M, False: 6.88k] ------------------ 1245| 13.2M| uint64_t chunk; 1246| 13.2M| std::memcpy(&chunk, it, 8); 1247| | if constexpr (std::endian::native == std::endian::big) { 1248| | chunk = std::byteswap(chunk); 1249| | } 1250| 13.2M| const uint64_t test = has_quote(chunk) | has_char(chunk) | has_char(chunk); 1251| 13.2M| if (test) { ------------------ | Branch (1251:14): [True: 3.07M, False: 10.2M] ------------------ 1252| 3.07M| it += (countr_zero(test) >> 3); 1253| | 1254| 3.07M| switch (*it) { 1255| 111k| case '"': { ------------------ | Branch (1255:13): [True: 111k, False: 2.96M] ------------------ 1256| 111k| skip_string(ctx, it, end); 1258| 111k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1258:20): [True: 324, False: 111k] ------------------ 1259| 324| return; 1260| 324| } 1261| 111k| break; 1262| 111k| } 1263| 2.92M| case open: { ------------------ | Branch (1263:13): [True: 2.92M, False: 146k] ------------------ 1264| 2.92M| ++it; 1265| 2.92M| ++depth; 1266| 2.92M| break; 1267| 111k| } 1268| 34.9k| case close: { ------------------ | Branch (1268:13): [True: 34.9k, False: 3.03M] ------------------ 1269| 34.9k| ++it; 1270| 34.9k| --depth; 1271| 34.9k| if (depth == 0) { ------------------ | Branch (1271:20): [True: 10.2k, False: 24.6k] ------------------ 1272| 10.2k| return; 1273| 10.2k| } 1274| 24.6k| break; 1275| 34.9k| } 1276| 24.6k| default: { ------------------ | Branch (1276:13): [True: 0, False: 3.07M] ------------------ 1277| 0| ctx.error = error_code::unexpected_end; 1278| 0| return; 1279| 34.9k| } 1280| 3.07M| } 1281| 3.07M| } 1282| 10.2M| else { 1283| 10.2M| it += 8; 1284| 10.2M| } 1285| 13.2M| } 1286| | 1287| | // Tail end of buffer. Should be rare we even get here 1288| 19.4k| while (it < end) { ------------------ | Branch (1288:14): [True: 17.3k, False: 2.10k] ------------------ 1289| 17.3k| switch (*it) { 1290| 3.75k| case '"': { ------------------ | Branch (1290:10): [True: 3.75k, False: 13.5k] ------------------ 1291| 3.75k| skip_string(ctx, it, end); 1293| 3.75k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1293:17): [True: 223, False: 3.52k] ------------------ 1294| 223| return; 1295| 223| } 1296| 3.52k| break; 1297| 3.75k| } 1298| 3.52k| case '/': { ------------------ | Branch (1298:10): [True: 79, False: 17.2k] ------------------ 1299| 79| skip_comment(ctx, it, end); 1300| 79| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1300:17): [True: 24, False: 55] ------------------ 1301| 24| return; 1302| 24| } 1303| 55| break; 1304| 79| } 1305| 679| case open: { ------------------ | Branch (1305:10): [True: 679, False: 16.6k] ------------------ 1306| 679| ++it; 1307| 679| ++depth; 1308| 679| break; 1309| 79| } 1310| 5.74k| case close: { ------------------ | Branch (1310:10): [True: 5.74k, False: 11.5k] ------------------ 1311| 5.74k| ++it; 1312| 5.74k| --depth; 1313| 5.74k| if (depth == 0) { ------------------ | Branch (1313:17): [True: 4.53k, False: 1.21k] ------------------ 1314| 4.53k| return; 1315| 4.53k| } 1316| 1.21k| break; 1317| 5.74k| } 1318| 7.04k| default: { ------------------ | Branch (1318:10): [True: 7.04k, False: 10.2k] ------------------ 1319| 7.04k| ++it; 1320| 7.04k| } 1321| 17.3k| } 1322| 17.3k| } 1323| | 1324| 2.10k| ctx.error = error_code::unexpected_end; 1325| 2.10k| } _ZN3glz8has_charILc91EEEDam: 550| 13.2M| { 551| 13.2M| return has_zero(chunk ^ repeat_byte8(Char)); 552| 13.2M| } _ZN3glz8has_charILc93EEEDam: 550| 13.2M| { 551| 13.2M| return has_zero(chunk ^ repeat_byte8(Char)); 552| 13.2M| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_: 1020| 19.9k| { 1021| 19.9k| if constexpr (not Opts.opening_handled) { 1022| 19.9k| ++it; 1023| 19.9k| } 1024| | 1025| 19.9k| const auto* const utf8_start = it; 1026| | 1027| | if constexpr (Opts.validate_skipped) { 1028| | while (true) { 1029| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1030| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1031| | // scan before each dereference. 1032| | if constexpr (not Opts.null_terminated) { 1033| | if (it == end) [[unlikely]] { 1034| | ctx.error = error_code::unexpected_end; 1035| | return; 1036| | } 1037| | } 1038| | if ((*it & 0b11100000) == 0) [[unlikely]] { 1039| | ctx.error = error_code::syntax_error; 1040| | return; 1041| | } 1042| | 1043| | switch (*it) { 1044| | case '"': { 1045| | validate_utf8_span(ctx, utf8_start, it); 1046| | ++it; 1047| | return; 1048| | } 1049| | case '\\': { 1050| | ++it; 1051| | if constexpr (not Opts.null_terminated) { 1052| | if (it == end) [[unlikely]] { 1053| | ctx.error = error_code::unexpected_end; 1054| | return; 1055| | } 1056| | } 1057| | if (char_unescape_table[uint8_t(*it)]) { 1058| | ++it; 1059| | continue; 1060| | } 1061| | else if (*it == 'u') { 1062| | ++it; 1063| | if (skip_unicode_code_point(it, end)) [[likely]] { 1064| | continue; 1065| | } 1066| | else [[unlikely]] { 1067| | ctx.error = error_code::unicode_escape_conversion_failure; 1068| | return; 1069| | } 1070| | } 1071| | ctx.error = error_code::syntax_error; 1072| | return; 1073| | } 1074| | } 1075| | ++it; 1076| | } 1077| | } 1078| 19.9k| else { 1079| 19.9k| skip_string_view(ctx, it, end); 1080| 19.9k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1080:14): [True: 95, False: 19.8k] ------------------ 1081| 95| return; 1082| 95| } 1083| 19.8k| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1083:14): [True: 192, False: 19.6k] ------------------ 1084| 192| return; 1085| 192| } 1086| 19.6k| ++it; // skip the quote 1087| 19.6k| } 1088| 19.9k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 19.8k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 19.8k| else { 840| 19.8k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 0, False: 19.8k] ------------------ 841| 0| return false; // pure ASCII is trivially well formed UTF-8 842| 0| } 843| 19.8k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 192, False: 19.6k] ------------------ 844| 192| ctx.error = error_code::invalid_utf8; 845| 192| return true; 846| 192| } 847| 19.6k| return false; 848| 19.8k| } 849| 19.8k| } _ZN3glz17match_invalid_endILc34EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 2.40M| { 412| 2.40M| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 2.30k, False: 2.40M] ------------------ 413| 2.30k| if constexpr (C == '"') { 414| 2.30k| ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 2.30k| return true; 432| 2.30k| } 433| 2.40M| else [[likely]] { 434| 2.40M| ++it; 435| 2.40M| } 436| 2.40M| if constexpr (not Opts.null_terminated) { 437| 2.40M| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 3, False: 2.40M] ------------------ 438| 3| ctx.error = error_code::unexpected_end; 439| 3| return true; 440| 3| } 441| 2.40M| } 442| 2.40M| return false; 443| 2.40M| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 760k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 760k| else { 840| 760k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 733k, False: 26.6k] ------------------ 841| 733k| return false; // pure ASCII is trivially well formed UTF-8 842| 733k| } 843| 26.6k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 14.4k, False: 12.1k] ------------------ 844| 14.4k| ctx.error = error_code::invalid_utf8; 845| 14.4k| return true; 846| 14.4k| } 847| 12.1k| return false; 848| 26.6k| } 849| 760k| } _ZN3glz25handle_unicode_code_pointIccEEjRPKT_RPT0_S3_: 288| 32.9k| { 289| 32.9k| using namespace unicode; 290| | 291| 32.9k| if (it + 4 >= end) [[unlikely]] { ------------------ | Branch (291:11): [True: 38, False: 32.9k] ------------------ 292| 38| return false; 293| 38| } 294| 32.9k| const uint32_t high = hex_to_u32(it); 295| 32.9k| if (high == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (295:11): [True: 107, False: 32.8k] ------------------ 296| 107| return false; 297| 107| } 298| 32.8k| it += 4; // skip the code point characters 299| | 300| 32.8k| uint32_t code_point; 301| | 302| 32.8k| if ((high & generic_surrogate_mask) == generic_surrogate_value) { ------------------ | Branch (302:11): [True: 2.27k, False: 30.5k] ------------------ 303| | // surrogate pair code points 304| 2.27k| if ((high & surrogate_mask) != high_surrogate_value) { ------------------ | Branch (304:14): [True: 18, False: 2.25k] ------------------ 305| 18| return false; 306| 18| } 307| | 308| 2.25k| if (it + 6 >= end) [[unlikely]] { ------------------ | Branch (308:14): [True: 20, False: 2.23k] ------------------ 309| 20| return false; 310| 20| } 311| | // The next two characters must be `\u` 312| 2.23k| uint16_t u; 313| 2.23k| std::memcpy(&u, it, 2); 314| 2.23k| if (u != to_uint16_t(R"(\u)")) [[unlikely]] { ------------------ | Branch (314:14): [True: 117, False: 2.11k] ------------------ 315| 117| return false; 316| 117| } 317| 2.11k| it += 2; 318| | // verify that second unicode escape sequence is present 319| 2.11k| const uint32_t low = hex_to_u32(it); 320| 2.11k| if (low == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (320:14): [True: 30, False: 2.08k] ------------------ 321| 30| return false; 322| 30| } 323| 2.08k| it += 4; 324| | 325| 2.08k| if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] { ------------------ | Branch (325:14): [True: 96, False: 1.99k] ------------------ 326| 96| return false; 327| 96| } 328| | 329| 1.99k| code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits; 330| 1.99k| code_point |= (low & surrogate_codepoint_mask); 331| 1.99k| code_point += surrogate_codepoint_offset; 332| 1.99k| } 333| 30.5k| else { 334| 30.5k| code_point = high; 335| 30.5k| } 336| 32.5k| const uint32_t offset = code_point_to_utf8(code_point, dst); 337| 32.5k| dst += offset; 338| 32.5k| return offset; 339| 32.8k| } _ZN3glz10hex_to_u32EPKc: 203| 156k| { 204| 156k| constexpr auto& t = digit_hex_table; 205| 156k| const uint8_t arr[4]{t[uint8_t(c[3])], t[uint8_t(c[2])], t[uint8_t(c[1])], t[uint8_t(c[0])]}; 206| 156k| auto chunk = std::bit_cast(arr); 207| | // On big-endian, bit_cast produces bytes in opposite order than expected 208| | // byteswap to get consistent little-endian representation 209| | if constexpr (std::endian::native == std::endian::big) { 210| | chunk = std::byteswap(chunk); 211| | } 212| | // check that all hex characters are valid 213| 156k| if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] { ------------------ | Branch (213:11): [True: 3.63k, False: 152k] ------------------ 214| 3.63k| return 0xFFFFFFFFu; 215| 3.63k| } 216| | 217| | // now pack into first four bytes of uint32_t 218| 152k| uint32_t packed{}; 219| 152k| packed |= (chunk & 0x0000000F); 220| 152k| packed |= (chunk & 0x00000F00) >> 4; 221| 152k| packed |= (chunk & 0x000F0000) >> 8; 222| 152k| packed |= (chunk & 0x0F000000) >> 12; 223| 152k| return packed; 224| 156k| } _ZN3glz18code_point_to_utf8IcEEjjPT_: 228| 32.5k| { 229| 32.5k| if (code_point <= 0x7F) { ------------------ | Branch (229:11): [True: 1.18k, False: 31.3k] ------------------ 230| 1.18k| c[0] = Char(code_point); 231| 1.18k| return 1; 232| 1.18k| } 233| 31.3k| if (code_point <= 0x7FF) { ------------------ | Branch (233:11): [True: 26.0k, False: 5.31k] ------------------ 234| 26.0k| c[0] = Char(0xC0 | ((code_point >> 6) & 0x1F)); 235| 26.0k| c[1] = Char(0x80 | (code_point & 0x3F)); 236| 26.0k| return 2; 237| 26.0k| } 238| 5.31k| if (code_point <= 0xFFFF) { ------------------ | Branch (238:11): [True: 3.32k, False: 1.99k] ------------------ 239| 3.32k| c[0] = Char(0xE0 | ((code_point >> 12) & 0x0F)); 240| 3.32k| c[1] = Char(0x80 | ((code_point >> 6) & 0x3F)); 241| 3.32k| c[2] = Char(0x80 | (code_point & 0x3F)); 242| 3.32k| return 3; 243| 3.32k| } 244| 1.99k| if (code_point <= 0x10FFFF) { ------------------ | Branch (244:11): [True: 1.99k, False: 0] ------------------ 245| 1.99k| c[0] = Char(0xF0 | ((code_point >> 18) & 0x07)); 246| 1.99k| c[1] = Char(0x80 | ((code_point >> 12) & 0x3F)); 247| 1.99k| c[2] = Char(0x80 | ((code_point >> 6) & 0x3F)); 248| 1.99k| c[3] = Char(0x80 | (code_point & 0x3F)); 249| 1.99k| return 4; 250| 1.99k| } 251| 0| return 0; 252| 1.99k| } _ZN3glz17match_invalid_endILc91EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 56.3k| { 412| 56.3k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 213, False: 56.1k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| 213| else if constexpr (C == '[' || C == ']') { 423| 213| ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 213| return true; 432| 213| } 433| 56.1k| else [[likely]] { 434| 56.1k| ++it; 435| 56.1k| } 436| 56.1k| if constexpr (not Opts.null_terminated) { 437| 56.1k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 16, False: 56.1k] ------------------ 438| 16| ctx.error = error_code::unexpected_end; 439| 16| return true; 440| 16| } 441| 56.1k| } 442| 56.1k| return false; 443| 56.3k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 1.63M| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 1.63M| else { 840| 1.63M| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 1.50M, False: 134k] ------------------ 841| 1.50M| return false; // pure ASCII is trivially well formed UTF-8 842| 1.50M| } 843| 134k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 34, False: 134k] ------------------ 844| 34| ctx.error = error_code::invalid_utf8; 845| 34| return true; 846| 34| } 847| 134k| return false; 848| 134k| } 849| 1.63M| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 1.73k| { 492| 1.73k| const auto n = size_t(end - it); 493| 1.73k| static constexpr auto S = str.sv(); 494| 1.73k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 321, False: 1.41k] | Branch (494:31): [True: 320, False: 1.09k] ------------------ 495| 641| ctx.error = error_code::syntax_error; 496| 641| } 497| 1.09k| else [[likely]] { 498| 1.09k| it += str.size(); 499| 1.09k| } 500| 1.73k| } _ZN3glz5matchILc34ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 447| 31.5k| { 448| 31.5k| if (*it != C) [[unlikely]] { ------------------ | Branch (448:11): [True: 0, False: 31.5k] ------------------ 449| 0| if constexpr (C == '"') { 450| 0| ctx.error = error_code::expected_quote; 451| | } 452| | else if constexpr (C == ',') { 453| | ctx.error = error_code::expected_comma; 454| | } 455| | else if constexpr (C == ':') { 456| | ctx.error = error_code::expected_colon; 457| | } 458| | else if constexpr (C == '[' || C == ']') { 459| | ctx.error = error_code::expected_bracket; 460| | } 461| | else if constexpr (C == '{' || C == '}') { 462| | ctx.error = error_code::expected_brace; 463| | } 464| | else { 465| | ctx.error = error_code::syntax_error; 466| | } 467| 0| return true; 468| 0| } 469| 31.5k| else [[likely]] { 470| 31.5k| ++it; 471| 31.5k| return false; 472| 31.5k| } 473| 31.5k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 1.20k| { 492| 1.20k| const auto n = size_t(end - it); 493| 1.20k| static constexpr auto S = str.sv(); 494| 1.20k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 15, False: 1.19k] | Branch (494:31): [True: 239, False: 954] ------------------ 495| 254| ctx.error = error_code::syntax_error; 496| 254| } 497| 954| else [[likely]] { 498| 954| it += str.size(); 499| 954| } 500| 1.20k| } _ZN3glz11skip_numberIXtlNS_16skip_number_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1526| 55.8k| { 1527| 55.8k| if constexpr (not Opts.validate) { 1528| | if constexpr (Opts.null_terminated) { 1529| | // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate. 1530| | while (numeric_table[uint8_t(*it)]) { 1531| | ++it; 1532| | } 1533| | } 1534| 55.8k| else { 1535| 14.2M| while (it < end && numeric_table[uint8_t(*it)]) { ------------------ | Branch (1535:20): [True: 14.2M, False: 37] | Branch (1535:32): [True: 14.1M, False: 55.8k] ------------------ 1536| 14.1M| ++it; 1537| 14.1M| } 1538| 55.8k| } 1539| | } 1540| | else { 1541| | skip_number_with_validation(ctx, it, end); 1542| | } 1543| 55.8k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 219k| { 492| 219k| const auto n = size_t(end - it); 493| 219k| static constexpr auto S = str.sv(); 494| 219k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 286, False: 218k] | Branch (494:31): [True: 593, False: 218k] ------------------ 495| 879| ctx.error = error_code::syntax_error; 496| 879| } 497| 218k| else [[likely]] { 498| 218k| it += str.size(); 499| 218k| } 500| 219k| } _ZN3glz5matchILc125ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 447| 38.4k| { 448| 38.4k| if (*it != C) [[unlikely]] { ------------------ | Branch (448:11): [True: 8.55k, False: 29.8k] ------------------ 449| | if constexpr (C == '"') { 450| | ctx.error = error_code::expected_quote; 451| | } 452| | else if constexpr (C == ',') { 453| | ctx.error = error_code::expected_comma; 454| | } 455| | else if constexpr (C == ':') { 456| | ctx.error = error_code::expected_colon; 457| | } 458| | else if constexpr (C == '[' || C == ']') { 459| | ctx.error = error_code::expected_bracket; 460| | } 461| 8.55k| else if constexpr (C == '{' || C == '}') { 462| 8.55k| ctx.error = error_code::expected_brace; 463| | } 464| | else { 465| | ctx.error = error_code::syntax_error; 466| | } 467| 8.55k| return true; 468| 8.55k| } 469| 29.8k| else [[likely]] { 470| 29.8k| ++it; 471| 29.8k| return false; 472| 29.8k| } 473| 38.4k| } _ZN3glz5matchILc93ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 447| 16.0k| { 448| 16.0k| if (*it != C) [[unlikely]] { ------------------ | Branch (448:11): [True: 1.82k, False: 14.2k] ------------------ 449| | if constexpr (C == '"') { 450| | ctx.error = error_code::expected_quote; 451| | } 452| | else if constexpr (C == ',') { 453| | ctx.error = error_code::expected_comma; 454| | } 455| | else if constexpr (C == ':') { 456| | ctx.error = error_code::expected_colon; 457| | } 458| 1.82k| else if constexpr (C == '[' || C == ']') { 459| 1.82k| ctx.error = error_code::expected_bracket; 460| | } 461| | else if constexpr (C == '{' || C == '}') { 462| | ctx.error = error_code::expected_brace; 463| | } 464| | else { 465| | ctx.error = error_code::syntax_error; 466| | } 467| 1.82k| return true; 468| 1.82k| } 469| 14.2k| else [[likely]] { 470| 14.2k| ++it; 471| 14.2k| return false; 472| 14.2k| } 473| 16.0k| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_6paddedEEvOT0_OT1_T2_: 1020| 200k| { 1021| 200k| if constexpr (not Opts.opening_handled) { 1022| 200k| ++it; 1023| 200k| } 1024| | 1025| 200k| const auto* const utf8_start = it; 1026| | 1027| 200k| if constexpr (Opts.validate_skipped) { 1028| 22.8M| while (true) { ------------------ | Branch (1028:17): [True: 22.8M, Folded] ------------------ 1029| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1030| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1031| | // scan before each dereference. 1032| 22.8M| if constexpr (not Opts.null_terminated) { 1033| 22.8M| if (it == end) [[unlikely]] { ------------------ | Branch (1033:20): [True: 176, False: 22.8M] ------------------ 1034| 176| ctx.error = error_code::unexpected_end; 1035| 176| return; 1036| 176| } 1037| 22.8M| } 1038| 22.8M| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1038:17): [True: 3.20k, False: 22.8M] ------------------ 1039| 3.20k| ctx.error = error_code::syntax_error; 1040| 3.20k| return; 1041| 3.20k| } 1042| | 1043| 22.8M| switch (*it) { ------------------ | Branch (1043:21): [True: 373k, False: 22.4M] ------------------ 1044| 181k| case '"': { ------------------ | Branch (1044:13): [True: 181k, False: 22.6M] ------------------ 1045| 181k| validate_utf8_span(ctx, utf8_start, it); 1046| 181k| ++it; 1047| 181k| return; 1048| 0| } 1049| 191k| case '\\': { ------------------ | Branch (1049:13): [True: 191k, False: 22.6M] ------------------ 1050| 191k| ++it; 1051| 191k| if constexpr (not Opts.null_terminated) { 1052| 191k| if (it == end) [[unlikely]] { ------------------ | Branch (1052:23): [True: 11, False: 191k] ------------------ 1053| 11| ctx.error = error_code::unexpected_end; 1054| 11| return; 1055| 11| } 1056| 191k| } 1057| 191k| if (char_unescape_table[uint8_t(*it)]) { ------------------ | Branch (1057:20): [True: 77.3k, False: 114k] ------------------ 1058| 77.3k| ++it; 1059| 77.3k| continue; 1060| 77.3k| } 1061| 114k| else if (*it == 'u') { ------------------ | Branch (1061:25): [True: 112k, False: 1.53k] ------------------ 1062| 112k| ++it; 1063| 112k| if (skip_unicode_code_point(it, end)) [[likely]] { ------------------ | Branch (1063:23): [True: 99.1k, False: 13.6k] ------------------ 1064| 99.1k| continue; 1065| 99.1k| } 1066| 13.6k| else [[unlikely]] { 1067| 13.6k| ctx.error = error_code::unicode_escape_conversion_failure; 1068| 13.6k| return; 1069| 13.6k| } 1070| 112k| } 1071| 1.53k| ctx.error = error_code::syntax_error; 1072| 1.53k| return; 1073| 191k| } 1074| 22.8M| } 1075| 22.4M| ++it; 1076| 22.4M| } 1077| | } 1078| | else { 1079| | skip_string_view(ctx, it, end); 1080| | if (bool(ctx.error)) [[unlikely]] { 1081| | return; 1082| | } 1083| | if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { 1084| | return; 1085| | } 1086| | ++it; // skip the quote 1087| | } 1088| 200k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 181k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 181k| else { 840| 181k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 0, False: 181k] ------------------ 841| 0| return false; // pure ASCII is trivially well formed UTF-8 842| 0| } 843| 181k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 474, False: 181k] ------------------ 844| 474| ctx.error = error_code::invalid_utf8; 845| 474| return true; 846| 474| } 847| 181k| return false; 848| 181k| } 849| 181k| } _ZN3glz23skip_unicode_code_pointIcEEbRPKT_S3_: 343| 112k| { 344| 112k| using namespace unicode; 345| 112k| if (it + 4 >= end) [[unlikely]] { ------------------ | Branch (345:11): [True: 5.02k, False: 107k] ------------------ 346| 5.02k| return false; 347| 5.02k| } 348| | 349| 107k| const uint32_t high = hex_to_u32(it); 350| 107k| if (high == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (350:11): [True: 1.85k, False: 105k] ------------------ 351| 1.85k| return false; 352| 1.85k| } 353| 105k| it += 4; // skip the code point characters 354| | 355| 105k| uint32_t code_point; 356| | 357| 105k| if ((high & generic_surrogate_mask) == generic_surrogate_value) { ------------------ | Branch (357:11): [True: 17.5k, False: 88.4k] ------------------ 358| | // surrogate pair code points 359| 17.5k| if ((high & surrogate_mask) != high_surrogate_value) [[unlikely]] { ------------------ | Branch (359:14): [True: 806, False: 16.7k] ------------------ 360| 806| return false; 361| 806| } 362| | 363| 16.7k| if (it + 6 >= end) [[unlikely]] { ------------------ | Branch (363:14): [True: 1.41k, False: 15.2k] ------------------ 364| 1.41k| return false; 365| 1.41k| } 366| | // The next two characters must be `\u` 367| 15.2k| uint16_t u; 368| 15.2k| std::memcpy(&u, it, 2); 369| 15.2k| if (u != to_uint16_t(R"(\u)")) [[unlikely]] { ------------------ | Branch (369:14): [True: 1.63k, False: 13.6k] ------------------ 370| 1.63k| return false; 371| 1.63k| } 372| 13.6k| it += 2; 373| | // verify that second unicode escape sequence is present 374| 13.6k| const uint32_t low = hex_to_u32(it); 375| 13.6k| if (low == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (375:14): [True: 1.64k, False: 12.0k] ------------------ 376| 1.64k| return false; 377| 1.64k| } 378| 12.0k| it += 4; 379| | 380| 12.0k| if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] { ------------------ | Branch (380:14): [True: 1.23k, False: 10.7k] ------------------ 381| 1.23k| return false; 382| 1.23k| } 383| | 384| 10.7k| code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits; 385| 10.7k| code_point |= (low & surrogate_codepoint_mask); 386| 10.7k| code_point += surrogate_codepoint_offset; 387| 10.7k| } 388| 88.4k| else { 389| 88.4k| code_point = high; 390| 88.4k| } 391| 99.1k| return skip_code_point(code_point) > 0; 392| 105k| } _ZN3glz15skip_code_pointEj: 255| 99.1k| { 256| 99.1k| if (code_point <= 0x7F) { ------------------ | Branch (256:11): [True: 6.55k, False: 92.6k] ------------------ 257| 6.55k| return 1; 258| 6.55k| } 259| 92.6k| if (code_point <= 0x7FF) { ------------------ | Branch (259:11): [True: 65.3k, False: 27.2k] ------------------ 260| 65.3k| return 2; 261| 65.3k| } 262| 27.2k| if (code_point <= 0xFFFF) { ------------------ | Branch (262:11): [True: 16.5k, False: 10.7k] ------------------ 263| 16.5k| return 3; 264| 16.5k| } 265| 10.7k| if (code_point <= 0x10FFFF) { ------------------ | Branch (265:11): [True: 10.7k, False: 0] ------------------ 266| 10.7k| return 4; 267| 10.7k| } 268| 0| return 0; 269| 10.7k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 5.30k| { 492| 5.30k| const auto n = size_t(end - it); 493| 5.30k| static constexpr auto S = str.sv(); 494| 5.30k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 849, False: 4.45k] | Branch (494:31): [True: 1.36k, False: 3.08k] ------------------ 495| 2.21k| ctx.error = error_code::syntax_error; 496| 2.21k| } 497| 3.08k| else [[likely]] { 498| 3.08k| it += str.size(); 499| 3.08k| } 500| 5.30k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 4.48k| { 492| 4.48k| const auto n = size_t(end - it); 493| 4.48k| static constexpr auto S = str.sv(); 494| 4.48k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 1.43k, False: 3.04k] | Branch (494:31): [True: 1.58k, False: 1.46k] ------------------ 495| 3.02k| ctx.error = error_code::syntax_error; 496| 3.02k| } 497| 1.46k| else [[likely]] { 498| 1.46k| it += str.size(); 499| 1.46k| } 500| 4.48k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 3.32k| { 492| 3.32k| const auto n = size_t(end - it); 493| 3.32k| static constexpr auto S = str.sv(); 494| 3.32k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 849, False: 2.47k] | Branch (494:31): [True: 913, False: 1.56k] ------------------ 495| 1.76k| ctx.error = error_code::syntax_error; 496| 1.76k| } 497| 1.56k| else [[likely]] { 498| 1.56k| it += str.size(); 499| 1.56k| } 500| 3.32k| } _ZN3glz11skip_numberIXtlNS_16skip_number_optsELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1526| 327k| { 1527| | if constexpr (not Opts.validate) { 1528| | if constexpr (Opts.null_terminated) { 1529| | // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate. 1530| | while (numeric_table[uint8_t(*it)]) { 1531| | ++it; 1532| | } 1533| | } 1534| | else { 1535| | while (it < end && numeric_table[uint8_t(*it)]) { 1536| | ++it; 1537| | } 1538| | } 1539| | } 1540| 327k| else { 1541| 327k| skip_number_with_validation(ctx, it, end); 1542| 327k| } 1543| 327k| } _ZN3glz27skip_number_with_validationITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 1453| 327k| { 1454| | // Every standalone *it read below is guarded by it != end so the scan stays inside the 1455| | // buffer for non-null-terminated input (the std::find_if_not calls are already bounded by 1456| | // end). A null-terminated buffer is unaffected: it reaches end only once the number is 1457| | // fully consumed, where these guards short-circuit exactly as the trailing '\0' sentinel 1458| | // would have. 1459| 327k| it += (it != end) && (*it == '-'); ------------------ | Branch (1459:13): [True: 327k, False: 0] | Branch (1459:28): [True: 91.1k, False: 236k] ------------------ 1460| 327k| const auto sig_start_it = it; 1461| 327k| auto frac_start_it = end; 1462| 327k| if (it != end && *it == '0') { ------------------ | Branch (1462:11): [True: 324k, False: 3.39k] | Branch (1462:24): [True: 19.6k, False: 304k] ------------------ 1463| 19.6k| ++it; 1464| | // RFC 8259 section 6: number = [ minus ] int [ frac ] [ exp ]. The exponent may follow 1465| | // the integer part directly, with no fractional part in between (e.g. "0e4"). 1466| 19.6k| if (it != end && (*it | ('E' ^ 'e')) == 'e') { ------------------ | Branch (1466:14): [True: 14.4k, False: 5.26k] | Branch (1466:27): [True: 3.86k, False: 10.5k] ------------------ 1467| 3.86k| ++it; 1468| 3.86k| goto exp_start; 1469| 3.86k| } 1470| 15.7k| if (it == end || *it != '.') { ------------------ | Branch (1470:14): [True: 5.26k, False: 10.5k] | Branch (1470:27): [True: 5.48k, False: 5.05k] ------------------ 1471| 10.7k| return; 1472| 10.7k| } 1473| 5.05k| ++it; 1474| 5.05k| goto frac_start; 1475| 15.7k| } 1476| 308k| it = std::find_if_not(it, end, is_digit); 1477| 308k| if (it == sig_start_it) { ------------------ | Branch (1477:11): [True: 135k, False: 172k] ------------------ 1478| 135k| ctx.error = error_code::syntax_error; 1479| 135k| return; 1480| 135k| } 1481| 172k| if (it != end && (*it | ('E' ^ 'e')) == 'e') { ------------------ | Branch (1481:11): [True: 100k, False: 72.9k] | Branch (1481:24): [True: 21.0k, False: 78.9k] ------------------ 1482| 21.0k| ++it; 1483| 21.0k| goto exp_start; 1484| 21.0k| } 1485| 151k| if (it == end || *it != '.') return; ------------------ | Branch (1485:11): [True: 72.9k, False: 78.9k] | Branch (1485:24): [True: 66.3k, False: 12.6k] ------------------ 1486| 12.6k| ++it; 1487| 17.6k| frac_start: 1488| 17.6k| frac_start_it = it; 1489| 17.6k| it = std::find_if_not(it, end, is_digit); 1490| 17.6k| if (it == frac_start_it) { ------------------ | Branch (1490:11): [True: 1.32k, False: 16.3k] ------------------ 1491| 1.32k| ctx.error = error_code::syntax_error; 1492| 1.32k| return; 1493| 1.32k| } 1494| 16.3k| if (it == end || (*it | ('E' ^ 'e')) != 'e') return; ------------------ | Branch (1494:11): [True: 2.11k, False: 14.2k] | Branch (1494:24): [True: 7.66k, False: 6.58k] ------------------ 1495| 6.58k| ++it; 1496| 31.4k| exp_start: 1497| 31.4k| it += (it != end) && (*it == '+' || *it == '-'); ------------------ | Branch (1497:13): [True: 31.1k, False: 384] | Branch (1497:29): [True: 7.72k, False: 23.3k] | Branch (1497:43): [True: 2.11k, False: 21.2k] ------------------ 1498| 31.4k| const auto exp_start_it = it; 1499| 31.4k| it = std::find_if_not(it, end, is_digit); 1500| 31.4k| if (it == exp_start_it) { ------------------ | Branch (1500:11): [True: 1.81k, False: 29.6k] ------------------ 1501| 1.81k| ctx.error = error_code::syntax_error; 1502| 1.81k| return; 1503| 1.81k| } 1504| 31.4k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_: 491| 845| { 492| 845| const auto n = size_t(end - it); 493| 845| static constexpr auto S = str.sv(); 494| 845| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 0, False: 845] | Branch (494:31): [True: 0, False: 845] ------------------ 495| 0| ctx.error = error_code::syntax_error; 496| 0| } 497| 845| else [[likely]] { 498| 845| it += str.size(); 499| 845| } 500| 845| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_: 491| 872| { 492| 872| const auto n = size_t(end - it); 493| 872| static constexpr auto S = str.sv(); 494| 872| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 0, False: 872] | Branch (494:31): [True: 0, False: 872] ------------------ 495| 0| ctx.error = error_code::syntax_error; 496| 0| } 497| 872| else [[likely]] { 498| 872| it += str.size(); 499| 872| } 500| 872| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_Qntcl15check_is_paddedT0_EEEvSE_OSF_T3_: 491| 905| { 492| 905| const auto n = size_t(end - it); 493| 905| static constexpr auto S = str.sv(); 494| 905| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 0, False: 905] | Branch (494:31): [True: 0, False: 905] ------------------ 495| 0| ctx.error = error_code::syntax_error; 496| 0| } 497| 905| else [[likely]] { 498| 905| it += str.size(); 499| 905| } 500| 905| } _ZNK3glz14string_literalILm4EE4sizeEv: 25| 19.6k| [[nodiscard]] constexpr size_t size() const noexcept { return length; } _ZNK3glz14string_literalILm5EE4sizeEv: 25| 446k| [[nodiscard]] constexpr size_t size() const noexcept { return length; } _ZN3glz6detail15get_source_infoITkNS_8has_sizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS0_11source_infoERKT_m: 39| 4.42M| { 40| 4.42M| using V = std::decay_t; 41| | 42| | if constexpr (std::same_as) { 43| | return {.context = "", .index = index}; 44| | } 45| 4.42M| else { 46| 4.42M| if (index >= buffer.size()) { ------------------ | Branch (46:17): [True: 4.09M, False: 337k] ------------------ 47| 4.09M| return {.context = "", .index = index}; 48| 4.09M| } 49| | 50| 337k| const auto start = std::begin(buffer) + index; 51| 337k| const auto line = size_t(std::count(std::begin(buffer), start, static_cast('\n')) + 1); 52| 337k| const auto rstart = std::rbegin(buffer) + buffer.size() - index - 1; 53| 337k| const auto prev_new_line = 54| 337k| std::find((std::min)(rstart + 1, std::rend(buffer)), std::rend(buffer), static_cast('\n')); 55| 337k| const auto column = size_t(std::distance(rstart, prev_new_line)); 56| 337k| const auto next_new_line = 57| 337k| std::find((std::min)(start + 1, std::end(buffer)), std::end(buffer), static_cast('\n')); 58| | 59| 337k| const auto offset = (prev_new_line == std::rend(buffer) ? 0 : index - column + 1); ------------------ | Branch (59:34): [True: 331k, False: 6.59k] ------------------ 60| 337k| auto context_begin = std::begin(buffer) + offset; 61| 337k| auto context_end = next_new_line; 62| | 63| 337k| size_t front_truncation = 0; 64| 337k| size_t rear_truncation = 0; 65| | 66| 337k| if (std::distance(context_begin, context_end) > 64) { ------------------ | Branch (66:17): [True: 30.8k, False: 307k] ------------------ 67| | // reduce the context length so that we can more easily see errors, especially for non-prettified buffers 68| 30.8k| if (column <= 32) { ------------------ | Branch (68:20): [True: 14.8k, False: 16.0k] ------------------ 69| 14.8k| rear_truncation = 64; 70| 14.8k| context_end = context_begin + rear_truncation; 71| 14.8k| } 72| 16.0k| else { 73| 16.0k| front_truncation = column - 32; 74| 16.0k| context_begin += front_truncation; 75| 16.0k| if (std::distance(context_begin, context_end) > 64) { ------------------ | Branch (75:23): [True: 8.03k, False: 7.97k] ------------------ 76| 8.03k| rear_truncation = front_truncation + 64; 77| 8.03k| context_end = std::begin(buffer) + offset + rear_truncation; 78| 8.03k| } 79| 16.0k| } 80| 30.8k| } 81| | 82| 337k| std::string context{context_begin, context_end}; 83| 337k| convert_tabs_to_single_spaces(context); 84| 337k| return {line, column, context, index, front_truncation, rear_truncation}; 85| 4.42M| } 86| 4.42M| } _ZN3glz6detail29convert_tabs_to_single_spacesERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 30| 337k| { 31| 4.82M| for (auto& c : input) { ------------------ | Branch (31:23): [True: 4.82M, False: 337k] ------------------ 32| 4.82M| if (c == '\t') { ------------------ | Branch (32:17): [True: 48.8k, False: 4.77M] ------------------ 33| 48.8k| c = ' '; 34| 48.8k| } 35| 4.82M| } 36| 337k| } _ZN3glz6detail21generate_error_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS0_11source_infoES5_: 97| 4.42M| { 98| 4.42M| std::string b{}; 99| 4.42M| b.resize(error.size() + info.context.size() + filename.size() + 128); 100| 4.42M| size_t ix{}; 101| | 102| 4.42M| if (not filename.empty()) { ------------------ | Branch (102:14): [True: 0, False: 4.42M] ------------------ 103| 0| dump_not_empty(filename, b, ix); 104| 0| dump(':', b, ix); 105| 0| } 106| | 107| 4.42M| glz::context ctx{}; 108| | 109| | // Diagnostic numbers (index/line/column) are always formatted with size-optimized 110| | // integer conversion: error formatting is never a throughput path, and this keeps 111| | // glz::format_error from pulling in the 40 KB integer table regardless of the 112| | // optimization level used elsewhere in the program. 113| 4.42M| if (info.context.empty()) { ------------------ | Branch (113:14): [True: 4.09M, False: 337k] ------------------ 114| 4.09M| dump("index ", b, ix); 115| 4.09M| write_chars::op(info.index, ctx, b, ix); 116| 4.09M| dump(": ", b, ix); 117| 4.09M| dump_maybe_empty(error, b, ix); 118| 4.09M| } 119| 337k| else { 120| 337k| write_chars::op(info.line, ctx, b, ix); 121| 337k| dump(':', b, ix); 122| 337k| write_chars::op(info.column, ctx, b, ix); 123| 337k| dump(": ", b, ix); 124| 337k| dump_maybe_empty(error, b, ix); 125| 337k| dump('\n', b, ix); 126| 337k| if (info.front_truncation) { ------------------ | Branch (126:17): [True: 16.0k, False: 321k] ------------------ 127| 16.0k| if (info.rear_truncation) { ------------------ | Branch (127:20): [True: 8.03k, False: 7.97k] ------------------ 128| 8.03k| dump("...", b, ix); 129| 8.03k| dump_maybe_empty(info.context, b, ix); 130| 8.03k| dump("...\n ", b, ix); 131| 8.03k| } 132| 7.97k| else { 133| 7.97k| dump("...", b, ix); 134| 7.97k| dump_maybe_empty(info.context, b, ix); 135| 7.97k| dump("\n ", b, ix); 136| 7.97k| } 137| 16.0k| } 138| 321k| else { 139| 321k| dump(" ", b, ix); 140| 321k| dump_maybe_empty(info.context, b, ix); 141| 321k| dump("\n ", b, ix); 142| 321k| } 143| 337k| dumpn(' ', info.column - 1 - info.front_truncation, b, ix); 144| 337k| dump('^', b, ix); 145| 337k| } 146| | 147| 4.42M| b.resize(ix); 148| 4.42M| return b; 149| 4.42M| } _ZN3glz8to_charsITkNSt3__114floating_pointEdLb0EEEPcS2_T_: 1118| 2.82k| { 1119| 2.82k| static_assert(std::is_same_v || std::is_same_v); 1120| 2.82k| return zmij::detail::write(val, buf); 1121| 2.82k| } _ZN3glz4zmij6detail5writeIdLb0EEEPcT_S3_: 975| 2.82k| { 976| 2.82k| using namespace detail_impl; 977| 2.82k| using traits = float_traits; 978| 2.82k| auto bits = traits::to_bits(value); 979| 2.82k| auto bin_exp = traits::get_exp(bits); 980| 2.82k| auto bin_sig = traits::get_sig(bits); 981| | 982| 2.82k| *buffer = '-'; 983| 2.82k| buffer += traits::is_negative(bits); 984| | 985| 2.82k| const auto* c = &consts_v; 986| 2.82k| ZMIJ_ASM(("" : "+r"(c))); ------------------ | | 126| 2.82k|#define ZMIJ_ASM(x) asm x ------------------ 987| 2.82k| int64_t threshold = traits::num_bits == 64 ? static_cast(c->threshold) : 10'000'000; ------------------ | Branch (987:30): [True: 2.82k, Folded] ------------------ 988| | 989| 2.82k| to_decimal_result dec; 990| 2.82k| bool is_normal = unsigned(bin_exp - 1) < unsigned(traits::exp_mask - 1); 991| 2.82k| if (!is_normal) [[unlikely]] { ------------------ | Branch (991:14): [True: 1.16k, False: 1.65k] ------------------ 992| 1.16k| if (bin_exp != 0) { ------------------ | Branch (992:17): [True: 0, False: 1.16k] ------------------ 993| |#if GLZ_ZMIJ_EMIT_INF_NAN 994| | memcpy(buffer, bin_sig == 0 ? "inf" : "nan", 4); 995| | return buffer + 3; 996| |#else 997| | // Undo the speculative '-' for sign-bit-set NaN/Inf: JSON "null" 998| | // never carries a sign. 999| 0| buffer -= traits::is_negative(bits); 1000| 0| memcpy(buffer, "null", 4); 1001| 0| return buffer + 4; 1002| 0|#endif 1003| 0| } 1004| 1.16k| if (bin_sig == 0) { ------------------ | Branch (1004:17): [True: 657, False: 508] ------------------ 1005| 657| memcpy(buffer, "0", 2); 1006| 657| return buffer + 1; 1007| 657| } 1008| 508| dec = detail_impl::to_decimal(bin_sig, 1, true, *c); 1009| 508| int64_t dec_sig = dec.sig * 10 + (dec.has_last_digit ? dec.last_digit : 0); ------------------ | Branch (1009:47): [True: 91, False: 417] ------------------ 1010| 508| int32_t dec_exp = dec.exp; 1011| 2.32k| while (dec_sig < threshold) { ------------------ | Branch (1011:20): [True: 1.81k, False: 508] ------------------ 1012| 1.81k| dec_sig *= 10; 1013| 1.81k| --dec_exp; 1014| 1.81k| } 1015| 508| int64_t d = static_cast(detail_impl::div10(static_cast(dec_sig))); 1016| 508| int32_t last_digit = static_cast(dec_sig - d * 10); 1017| 508| dec = {d, dec_exp, last_digit, last_digit != 0}; 1018| 508| } 1019| 1.65k| else { 1020| 1.65k| dec = detail_impl::to_decimal(bin_sig | traits::implicit_bit, 1021| 1.65k| bin_exp, bin_sig != 0, *c); 1022| 1.65k| } 1023| 2.16k| bool extra_digit = dec.sig >= threshold; 1024| 2.16k| int dec_exp = dec.exp + traits::max_digits10 - 2 + extra_digit; 1025| 2.16k| if (traits::num_bits == 32 && dec.sig < 1'000'000) [[unlikely]] { ------------------ | Branch (1025:14): [Folded, False: 2.16k] | Branch (1025:40): [True: 0, False: 0] ------------------ 1026| 0| dec.sig = 10 * dec.sig + (dec.has_last_digit ? dec.last_digit : 0); ------------------ | Branch (1026:39): [True: 0, False: 0] ------------------ 1027| 0| dec.has_last_digit = false; 1028| 0| --dec_exp; 1029| 0| } 1030| | 1031| 2.16k| char* start = buffer; 1032| 2.16k| auto dig = to_digits(static_cast(dec.sig), extra_digit, *c); 1033| 2.16k| constexpr int bcd_size = traits::num_bits == 64 ? 16 : 8; ------------------ | Branch (1033:35): [True: 0, Folded] ------------------ 1034| 2.16k| if (dec_exp >= traits::min_fixed_dec_exp && dec_exp <= traits::max_fixed_dec_exp) { ------------------ | Branch (1034:14): [True: 1.53k, False: 628] | Branch (1034:54): [True: 900, False: 637] ------------------ 1035| 900| memcpy(start, &zeros_v, 8); 1036| 900| const auto& fmt = dec_exp_formats.get(dec_exp); 1037| 900| buffer += fmt.start_pos; 1038| 900| memcpy(buffer, &dig.digits, bcd_size); 1039| 900| memmove(buffer, buffer + !extra_digit, bcd_size); 1040| 900| buffer[bcd_size + extra_digit - 1] = static_cast('0' + (dec.has_last_digit ? dec.last_digit : 0)); ------------------ | Branch (1040:75): [True: 162, False: 738] ------------------ 1041| 900| memmove(start + fmt.shift_pos, start + fmt.point_pos, bcd_size); 1042| 900| start[fmt.point_pos] = '.'; 1043| 900| int num_digits = dec.has_last_digit ? bcd_size : dig.num_digits - 1; ------------------ | Branch (1043:30): [True: 162, False: 738] ------------------ 1044| 900| return buffer + fmt.exp_pos[num_digits + extra_digit - 1]; 1045| 900| } 1046| 1.26k| buffer += extra_digit; 1047| 1.26k| memcpy(buffer, &dig.digits, bcd_size); 1048| 1.26k| buffer[bcd_size] = static_cast('0' + dec.last_digit); 1049| 1.26k| buffer += dec.has_last_digit ? bcd_size + 1 : dig.num_digits; ------------------ | Branch (1049:20): [True: 362, False: 903] ------------------ 1050| 1.26k| start[0] = start[1]; 1051| 1.26k| start[1] = '.'; 1052| 1.26k| buffer -= (buffer - 1 == start + 1); 1053| | 1054| 1.26k| if constexpr (exp_string_table::enable) { 1055| 1.26k| uint64_t exp_data = exp_strings_v.data[dec_exp + exp_string_table::offset]; 1056| 1.26k| int len = int(exp_data >> 48); 1057| 1.26k| if (is_big_endian) exp_data = bswap64(exp_data); ------------------ | Branch (1057:17): [Folded, False: 1.26k] ------------------ 1058| 1.26k| memcpy(buffer, &exp_data, traits::max_exponent10 >= 100 ? 8 : 4); ------------------ | Branch (1058:39): [True: 1.26k, Folded] ------------------ 1059| 1.26k| return buffer + len; 1060| 1.26k| } 1061| | // Glaze emits uppercase 'E', omits '+' on positive exponents, and 1062| | // drops the leading zero on single-digit exponents (E7, not E07). 1063| | // Branchless: write "E-" always, then advance past the '-' only when 1064| | // the exponent is negative. 1065| 0| bool neg = dec_exp < 0; 1066| 1.26k| buffer[0] = 'E'; 1067| 1.26k| buffer[1] = '-'; 1068| 1.26k| buffer += 1 + unsigned(neg); 1069| 1.26k| dec_exp = neg ? -dec_exp : dec_exp; ------------------ | Branch (1069:20): [True: 0, False: 1.26k] ------------------ 1070| 1.26k| unsigned hundreds_written = 0; 1071| 1.26k| if constexpr (traits::max_exponent10 >= 100) { 1072| 1.26k| int32_t digit = 0; 1073| | if constexpr (use_umul128_hi64) { 1074| | digit = static_cast(umul128_hi64(static_cast(dec_exp), 0x290000000000000ull)); 1075| | } 1076| 1.26k| else { 1077| 1.26k| digit = static_cast((uint32_t(dec_exp) * div100_sig) >> div100_exp); 1078| 1.26k| } 1079| 1.26k| *buffer = static_cast('0' + digit); 1080| 1.26k| hundreds_written = unsigned(dec_exp >= 100); 1081| 1.26k| buffer += hundreds_written; 1082| 1.26k| dec_exp -= digit * 100; 1083| 1.26k| } 1084| | // dec_exp now in [0, 99]. Skip the tens digit only when no higher 1085| | // digit has been written (i.e. true leading zero, not interior). 1086| 1.26k| const char* d2 = digits2(dec_exp); 1087| 1.26k| *buffer = d2[0]; 1088| 1.26k| buffer += hundreds_written | unsigned(dec_exp >= 10); 1089| 1.26k| *buffer = d2[1]; 1090| 1.26k| return buffer + 1; 1091| 2.16k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7to_bitsEd: 358| 2.82k| { 359| 2.82k| sig_type bits; 360| 2.82k| memcpy(&bits, &value, sizeof(value)); 361| 2.82k| return bits; 362| 2.82k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_expEm: 367| 2.82k| { 368| 2.82k| return static_cast((bits << 1) >> (num_sig_bits + 1)); 369| 2.82k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_sigEm: 365| 2.82k| static auto get_sig(sig_type bits) noexcept -> sig_type { return bits & (implicit_bit - 1); } _ZN3glz4zmij11detail_impl12float_traitsIdE11is_negativeEm: 364| 2.82k| static auto is_negative(sig_type bits) noexcept -> bool { return bits >> (num_bits - 1); } _ZN3glz4zmij11detail_impl10to_decimalIdmLb0EEENS1_17to_decimal_resultET0_lbRKNS1_9constantsIXT1_EEE: 868| 2.16k| { 869| 2.16k| using traits = float_traits; 870| 2.16k| int64_t bin_exp = raw_exp - traits::exp_offset; 871| 2.16k| constexpr int num_bits = std::numeric_limits::digits; 872| | 873| 2.16k| constexpr uint64_t log10_2_sig = 78'913; 874| 2.16k| constexpr int32_t log10_2_exp = 18; 875| 2.16k| int32_t dec_exp = 0; 876| | if constexpr (use_umul128_hi64) { 877| | dec_exp = 878| | static_cast(umul128_hi64(static_cast(bin_exp), log10_2_sig << (64 - log10_2_exp))); 879| | } 880| 2.16k| else { 881| 2.16k| dec_exp = compute_dec_exp(bin_exp); 882| 2.16k| } 883| 2.16k| uint64_t even = 1 - (bin_sig & 1); 884| 2.16k| constexpr int32_t extra_shift = exp_shift_table::extra_shift; 885| | 886| 2.16k| if (!regular) [[unlikely]] { ------------------ | Branch (886:14): [True: 373, False: 1.79k] ------------------ 887| 373| int32_t irregular_dec_exp = compute_dec_exp(bin_exp, false); 888| 373| int32_t shift = compute_exp_shift(bin_exp, irregular_dec_exp + 1) + extra_shift; 889| 373| uint128 pow10 = c.pow10_significands[-irregular_dec_exp - 1]; 890| 373| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 891| | 892| 373| int64_t integral = p.hi >> extra_shift; 893| 373| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 894| | 895| 373| uint64_t half_ulp = pow10.hi >> (extra_shift + 1 - shift); 896| 373| bool round_up = half_ulp > ~uint64_t(0) - fractional; 897| 373| bool round_down = (half_ulp >> 1) > fractional; 898| 373| integral += round_up; 899| | 900| 373| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, (uint64_t(1) << 63) - 1)); 901| 373| int32_t lo = static_cast(umul128_add_hi64(fractional - (half_ulp >> 1), 10, ~uint64_t(0))); 902| 373| if (digit < lo) digit = lo; ------------------ | Branch (902:17): [True: 341, False: 32] ------------------ 903| 373| return {integral, irregular_dec_exp, digit, (round_up + round_down) == 0}; 904| 373| } 905| | 906| | if constexpr (num_bits == 32) { 907| | constexpr int32_t float_extra_shift = 34; 908| | int32_t shift = compute_exp_shift(bin_exp, dec_exp + 1) + float_extra_shift; 909| | uint64_t pow10_hi = c.pow10_significands[-dec_exp - 1].hi; 910| | uint64_t p = umul128_hi64(pow10_hi + 1, uint64_t(bin_sig) << shift); 911| | 912| | int64_t integral = p >> float_extra_shift; 913| | uint64_t fractional = p & ((1ull << float_extra_shift) - 1); 914| | 915| | uint64_t half_ulp = (pow10_hi >> (65 - shift)) + even; 916| | bool round_up = (fractional + half_ulp) >> float_extra_shift; 917| | bool round_down = half_ulp > fractional; 918| | integral += round_up; 919| | 920| | uint64_t prod = fractional * 10; 921| | int32_t digit = static_cast(prod >> float_extra_shift); 922| | uint64_t rem = prod & ((1ull << float_extra_shift) - 1); 923| | digit += 924| | rem > (1ull << (float_extra_shift - 1)) || (rem == (1ull << (float_extra_shift - 1)) && (digit & 1)); 925| | return {integral, dec_exp, digit, (round_up + round_down) == 0}; 926| | } 927| 1.79k| else { 928| 1.79k| int32_t shift = exp_shift_table::enable ? exp_shifts_v.data[bin_exp + traits::exp_offset] ------------------ | Branch (928:29): [True: 1.79k, Folded] ------------------ 929| 1.79k| : compute_exp_shift(bin_exp, dec_exp + 1) + extra_shift; 930| 1.79k| ZMIJ_ASM(("" : "+r"(dec_exp))); ------------------ | | 126| 1.79k|#define ZMIJ_ASM(x) asm x ------------------ 931| 1.79k| uint128 pow10 = c.pow10_significands[-dec_exp - 1]; 932| 1.79k| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 933| 1.79k| int64_t integral = p.hi >> extra_shift; 934| 1.79k| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 935| 1.79k| uint64_t half_ulp = (pow10.hi >> (extra_shift + 1 - shift)) + even; 936| 1.79k| bool round_up = fractional + half_ulp < fractional; 937| 1.79k| bool round_down = half_ulp > fractional; 938| 1.79k| integral += round_up; 939| | 940| 1.79k| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, c.biased_half)); 941| 1.79k| if (fractional == (1ull << 62)) [[unlikely]] { ------------------ | Branch (941:17): [True: 3, False: 1.78k] ------------------ 942| 3| digit = 2; 943| 3| } 944| 1.79k| return {integral, dec_exp, digit, (round_up + round_down) == 0}; 945| 1.79k| } 946| 1.79k| } _ZN3glz4zmij11detail_impl15compute_dec_expElb: 333| 2.53k| { 334| 2.53k| assert(bin_exp >= -1334 && bin_exp <= 2620); ------------------ | Branch (334:10): [True: 2.53k, False: 0] | Branch (334:10): [True: 2.53k, False: 0] | Branch (334:10): [True: 2.53k, False: 0] ------------------ 335| 2.53k| constexpr int log10_3_over_4_sig = 131'072; 336| 2.53k| constexpr int log10_2_sig = 315'653, log10_2_exp = 20; 337| 2.53k| return static_cast((bin_exp * log10_2_sig - !regular * log10_3_over_4_sig) >> log10_2_exp); 338| 2.53k| } _ZN3glz4zmij11detail_impl17compute_exp_shiftEli: 457| 373| { 458| 373| assert(dec_exp >= -350 && dec_exp <= 350); ------------------ | Branch (458:10): [True: 373, False: 0] | Branch (458:10): [True: 373, False: 0] | Branch (458:10): [True: 373, False: 0] ------------------ 459| 373| constexpr int log2_pow10_sig = 217'707, log2_pow10_exp = 16; 460| 373| int pow10_bin_exp = -dec_exp * log2_pow10_sig >> log2_pow10_exp; 461| 373| return static_cast(bin_exp + pow10_bin_exp + 1); 462| 373| } _ZNK3glz4zmij11detail_impl23pow10_significand_tableILb0EEixEi: 440| 2.16k| { 441| 2.16k| constexpr int dec_exp_min = -293; 442| 2.16k| int i = dec_exp - dec_exp_min; 443| 2.16k| if (compress) return compute(i); ------------------ | Branch (443:17): [Folded, False: 2.16k] ------------------ 444| 2.16k| if (!split_tables) return {data[i * 2], data[i * 2 + 1]}; ------------------ | Branch (444:17): [True: 2.16k, Folded] ------------------ 445| | 446| 0| const uint64_t* hi = data + num_pow10s + dec_exp_min - 1; 447| 0| const uint64_t* lo = hi + num_pow10s; 448| | 449| 0| if !consteval { 450| 0| ZMIJ_ASM(volatile("" : "+r"(hi), "+r"(lo))); ------------------ | | 126| 0|#define ZMIJ_ASM(x) asm x ------------------ 451| 0| } 452| 0| return {hi[-dec_exp], lo[-dec_exp]}; 453| 2.16k| } _ZN3glz4zmij11detail_impl13umul192_hi128Emmm: 308| 2.16k| { 309| 2.16k| uint128_t p = umul128(x_hi, y); 310| 2.16k| uint64_t lo = uint64_t(p) + uint64_t(umul128(x_lo, y) >> 64); 311| 2.16k| return {uint64_t(p >> 64) + (lo < uint64_t(p)), lo}; 312| 2.16k| } _ZN3glz4zmij11detail_impl7umul128Emm: 265| 4.83k| { 266| 4.83k|#if ZMIJ_USE_INT128 267| 4.83k| return uint128_t(x) * y; 268| |#else 269| |#if defined(_M_AMD64) 270| | if !consteval { 271| | uint64_t hi = 0; 272| | uint64_t lo = _umul128(x, y, &hi); 273| | return {hi, lo}; 274| | } 275| |#elif defined(_M_ARM64) 276| | if !consteval { 277| | return {__umulh(x, y), x * y}; 278| | } 279| |#endif 280| | uint64_t a = x >> 32; 281| | uint64_t b = uint32_t(x); 282| | uint64_t c = y >> 32; 283| | uint64_t d = uint32_t(y); 284| | 285| | uint64_t ac = a * c; 286| | uint64_t bc = b * c; 287| | uint64_t ad = a * d; 288| | uint64_t bd = b * d; 289| | 290| | uint64_t cs = (bd >> 32) + uint32_t(ad) + uint32_t(bc); 291| | return {ac + (ad >> 32) + (bc >> 32) + (cs >> 32), (cs << 32) + uint32_t(bd)}; 292| |#endif 293| 4.83k| } _ZN3glz4zmij11detail_impl16umul128_add_hi64Emmm: 298| 2.53k| { 299| 2.53k|#if ZMIJ_USE_INT128 300| 2.53k| return uint64_t((uint128_t(x) * y + c) >> 64); 301| |#else 302| | auto p = umul128(x, y); 303| | return p.hi + (p.lo + c < p.lo); 304| |#endif 305| 2.53k| } _ZN3glz4zmij11detail_impl5div10Em: 326| 508| { 327| 508| assert(x <= (1ull << 62)); ------------------ | Branch (327:10): [True: 508, False: 0] ------------------ 328| 508| constexpr uint64_t div10_sig64 = (1ull << 63) / 5 + 1; 329| 508| return ZMIJ_USE_INT128 ? umul128_hi64(x, div10_sig64) : x / 10; ------------------ | | 247| 508|#define ZMIJ_USE_INT128 1 | | ------------------ | | | Branch (247:25): [True: 508, Folded] | | ------------------ ------------------ 330| 508| } _ZN3glz4zmij11detail_impl12umul128_hi64Emm: 295| 508| constexpr auto umul128_hi64(uint64_t x, uint64_t y) noexcept -> uint64_t { return uint64_t(umul128(x, y) >> 64); } _ZN3glz4zmij11detail_impl9to_digitsILi64ELb0EEENS1_10dec_digitsIXT_EEEmbRKNS1_9constantsIXT0_EEE: 809| 2.16k| { 810| | if constexpr (num_bits == 32) { 811| | auto result = to_bcd8(value); 812| | return {result.bcd + zeros_v, result.len}; 813| | } 814| 2.16k| else { 815| |#if !ZMIJ_USE_NEON && !ZMIJ_USE_SSE 816| | uint32_t bbccddee = uint32_t(value / 100'000'000); 817| | uint32_t ffgghhii = uint32_t(value % 100'000'000); 818| | auto hi = to_bcd8(bbccddee); 819| | if (ffgghhii == 0) return {{hi.bcd + zeros_v, zeros_v}, hi.len}; 820| | auto lo = to_bcd8(ffgghhii); 821| | return {{hi.bcd + zeros_v, lo.bcd + zeros_v}, 8 + lo.len}; 822| |#elif ZMIJ_USE_NEON 823| | auto unshuffled_digits = to_unshuffled_digits(value, c); 824| | uint8x16_t digits = vrev64q_u8(unshuffled_digits); 825| | uint16x8_t str = vaddq_u16(vreinterpretq_u16_u8(digits), vreinterpretq_u16_s8(vdupq_n_s8('0'))); 826| | 827| | // vcgtzq_s8 is AArch64-only; the portable spelling (ARMv7 NEON and 828| | // up) is "compare greater-than against a zero vector". 829| | uint16x8_t is_not_zero = vreinterpretq_u16_u8(vcgtq_s8(vreinterpretq_s8_u8(digits), vdupq_n_s8(0))); 830| | uint64_t zeroes = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(is_not_zero, 4)), 0); 831| | return {str, 16 - (clz(zeroes) >> 2)}; 832| |#else 833| 2.16k| uint32_t abbccddee = uint32_t(value / 100'000'000); 834| 2.16k| uint32_t ffgghhii = uint32_t(value % 100'000'000); 835| | 836| 2.16k| const __m128i zeros = _mm_load_si128(m128ptr(&c.zeros)); 837| 2.16k| auto unshuffled_bcd = to_unshuffled_digits(abbccddee, ffgghhii, c); 838| |#if ZMIJ_USE_SSE4_1 839| | const __m128i bswap = _mm_load_si128(m128ptr(&c.bswap)); 840| | auto bcd = _mm_shuffle_epi8(unshuffled_bcd, bswap); 841| |#else 842| 2.16k| auto bcd = _mm_shuffle_epi32(unshuffled_bcd, _MM_SHUFFLE(0, 1, 2, 3)); 843| 2.16k|#endif 844| | 845| 2.16k| __m128i mask128 = _mm_cmpgt_epi8(bcd, _mm_setzero_si128()); 846| 2.16k| uint64_t mask = _mm_movemask_epi8(mask128); 847| |#if defined(__LZCNT__) && !defined(ZMIJ_NO_BUILTINS) 848| | int len = 32 - _lzcnt_u32(mask); 849| |#else 850| 2.16k| int len = 63 - clz((mask << 1) | 1); 851| 2.16k|#endif 852| 2.16k| return {_mm_or_si128(bcd, zeros), len}; 853| 2.16k|#endif 854| 2.16k| } 855| 2.16k| } _ZN3glz4zmij11detail_impl20to_unshuffled_digitsILb0EEEDv2_xjjRKNS1_9constantsIXT_EEE: 735| 2.16k| { 736| 2.16k| const __m128i div10k = _mm_load_si128(m128ptr(&c.div10k)); 737| 2.16k| const __m128i neg10k = _mm_load_si128(m128ptr(&c.neg10k)); 738| 2.16k| __m128i x = _mm_set_epi64x(bbccddee, ffgghhii); 739| 2.16k| __m128i y = _mm_add_epi64(x, _mm_mul_epu32(neg10k, _mm_srli_epi64(_mm_mul_epu32(x, div10k), div10k_exp))); 740| 2.16k| return to_bcd_4x4(y, c); 741| 2.16k| } _ZN3glz4zmij11detail_impl10to_bcd_4x4ILb0EEEDv2_xS3_RKNS1_9constantsIXT_EEE: 712| 2.16k| { 713| 2.16k| const __m128i div100 = _mm_load_si128(m128ptr(&c.div100)); 714| 2.16k| const __m128i div10 = _mm_load_si128(m128ptr(&c.div10)); 715| |#if ZMIJ_USE_SSE4_1 716| | const __m128i neg100 = _mm_load_si128(m128ptr(&c.neg100)); 717| | const __m128i neg10 = _mm_load_si128(m128ptr(&c.neg10)); 718| | 719| | __m128i z = _mm_add_epi64(y, _mm_mullo_epi32(neg100, _mm_srli_epi32(_mm_mulhi_epu16(y, div100), 3))); 720| | return _mm_add_epi16(z, _mm_mullo_epi16(neg10, _mm_mulhi_epu16(z, div10))); 721| |#else 722| 2.16k| const __m128i hundred = _mm_load_si128(m128ptr(&c.hundred)); 723| 2.16k| const __m128i moddiv10 = _mm_load_si128(m128ptr(&c.moddiv10)); 724| | 725| 2.16k| __m128i y_div_100 = _mm_srli_epi16(_mm_mulhi_epu16(y, div100), 3); 726| 2.16k| __m128i y_mod_100 = _mm_sub_epi16(y, _mm_mullo_epi16(y_div_100, hundred)); 727| 2.16k| __m128i z = _mm_or_si128(_mm_slli_epi32(y_mod_100, 16), y_div_100); 728| 2.16k| return _mm_sub_epi16(_mm_slli_epi16(z, 8), _mm_mullo_epi16(moddiv10, _mm_mulhi_epu16(z, div10))); 729| 2.16k|#endif 730| 2.16k| } _ZN3glz4zmij11detail_impl3clzEm: 187| 2.16k| { 188| 2.16k| assert(x != 0); ------------------ | Branch (188:10): [True: 2.16k, False: 0] ------------------ 189| 2.16k|#if ZMIJ_HAS_BUILTIN(__builtin_clzll) 190| 2.16k| return __builtin_clzll(x); 191| |#elif defined(_M_AMD64) && defined(__AVX2__) 192| | return __lzcnt64(x); 193| |#elif defined(_M_AMD64) || defined(_M_ARM64) 194| | unsigned long idx; 195| | _BitScanReverse64(&idx, x); 196| | return 63 - idx; 197| |#elif ZMIJ_MSC_VER 198| | unsigned long idx; 199| | if (_BitScanReverse(&idx, uint32_t(x >> 32))) return 31 - idx; 200| | _BitScanReverse(&idx, uint32_t(x)); 201| | return 63 - idx; 202| |#else 203| | int n = 64; 204| | for (; x > 0; x >>= 1) --n; 205| | return n; 206| |#endif 207| 2.16k| } _ZNK3glz4zmij11detail_impl20dec_exp_format_table3getINS1_12float_traitsIdEEEERKNS2_5entryEi: 559| 900| { 560| 900| constexpr auto min = traits::min_fixed_dec_exp, max = Traits::max_fixed_dec_exp; 561| 900| unsigned i = unsigned(dec_exp - min); 562| 900| return data[i <= unsigned(max - min) ? i : num_entries - 1]; ------------------ | Branch (562:25): [True: 900, False: 0] ------------------ 563| 900| }