LLVMFuzzerTestOneInput: 143| 26.5k|{ 144| 26.5k| const std::string_view input{reinterpret_cast(Data), Size}; 145| | 146| | // Raw bytes: the batch split, the syntax check, and the envelope read. 147| 26.5k| { 148| 26.5k| const auto buf = exact_buffer(input); 149| 26.5k| drive({buf.data(), buf.size()}); 150| 26.5k| } 151| | 152| 26.5k| if (Size < 1) { ------------------ | Branch (152:8): [True: 0, False: 26.5k] ------------------ 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| 26.5k| static constexpr std::string_view methods[] = { 163| 26.5k| "", "value", "name", "position", "position/x", "inner", "series", "table", "maybe", "measure", 164| 26.5k| "doubled", "greet", "midpoint", "total", "reset", "counter", "scale", "bump", "shift", "absent"}; 165| 26.5k| const std::string_view method = methods[Data[0] % (sizeof(methods) / sizeof(methods[0]))]; 166| 26.5k| const std::string_view params = input.substr(1); 167| | 168| 26.5k| { 169| 26.5k| std::string request; 170| 26.5k| request += R"({"jsonrpc":"2.0","method":")"; 171| 26.5k| request += method; 172| 26.5k| request += R"(","params":)"; 173| 26.5k| request += params; 174| 26.5k| request += R"(,"id":1})"; 175| | 176| 26.5k| const auto buf = exact_buffer(request); 177| 26.5k| drive({buf.data(), buf.size()}); 178| 26.5k| } 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| 26.5k| { 183| 26.5k| std::string request; 184| 26.5k| request += R"([{"jsonrpc":"2.0","method":")"; 185| 26.5k| request += method; 186| 26.5k| request += R"(","params":)"; 187| 26.5k| request += params; 188| 26.5k| request += R"(,"id":1},{"jsonrpc":"2.0","method":")"; 189| 26.5k| request += method; 190| 26.5k| request += R"("}])"; // second element is a notification, so it takes the no-response path 191| | 192| 26.5k| const auto buf = exact_buffer(request); 193| 26.5k| drive({buf.data(), buf.size()}); 194| 26.5k| } 195| | 196| 26.5k| return 0; 197| 26.5k|} jsonrpc_registry.cpp:_ZN12_GLOBAL__N_112exact_bufferENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 111| 155k| { 112| 155k| std::vector buf(bytes.size()); 113| 155k| if (!bytes.empty()) { ------------------ | Branch (113:11): [True: 155k, False: 0] ------------------ 114| 155k| std::memcpy(buf.data(), bytes.data(), bytes.size()); 115| 155k| } 116| 155k| return buf; 117| 155k| } jsonrpc_registry.cpp:_ZN12_GLOBAL__N_15driveENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 120| 79.7k| { 121| 79.7k| glz::registry registry; 122| 79.7k| fuzz_api api{}; 123| 79.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| 79.7k| registry.on(members); 128| 79.7k| registry.on(api); 129| | 130| 79.7k| const auto response = registry.call(request); 131| 79.7k| if (!response.empty()) { ------------------ | Branch (131:11): [True: 75.5k, False: 4.19k] ------------------ 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| 75.5k| const auto buf = exact_buffer(response); 135| 75.5k| glz::generic parsed{}; 136| 75.5k| [[maybe_unused]] auto ec = 137| 75.5k| glz::read(parsed, std::string_view{buf.data(), buf.size()}); 138| 75.5k| } 139| 79.7k| } _ZNK12jsonrpc_fuzz8fuzz_api7doubledMUliE_clEi: 66| 1.21k| std::function doubled = [](int32_t v) { return int32_t(uint32_t(v) * 2u); }; _ZNK12jsonrpc_fuzz8fuzz_api5greetMUlRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE_clESA_: 67| 2.99k| std::function greet = [](const std::string& who) { return "hi " + who; }; _ZNK12jsonrpc_fuzz8fuzz_api8midpointMUlRKNS_5pointEE_clES4_: 68| 1.03k| std::function midpoint = [](const point& p) -> point { return {p.x / 2, p.y / 2}; }; _ZNK12jsonrpc_fuzz8fuzz_api5totalMUlRNSt3__16vectorIdNS2_9allocatorIdEEEEE_clES7_: 69| 4.26k| std::function&)> total = [](std::vector& v) { 70| 4.26k| double sum{}; 71| 69.5k| for (auto d : v) sum += d; ------------------ | Branch (71:22): [True: 69.5k, False: 4.26k] ------------------ 72| 4.26k| return sum; 73| 4.26k| }; _ZNK12jsonrpc_fuzz8fuzz_api5resetMUlvE_clEv: 74| 687| std::function reset = [] {}; _ZN12jsonrpc_fuzz10member_api5scaleEi: 89| 788| { 90| 788| counter = int32_t(uint32_t(counter) + uint32_t(v)); 91| 788| return int32_t(uint32_t(v) * 3u); 92| 788| } _ZN12jsonrpc_fuzz10member_api4bumpEv: 93| 429| void bump() { counter = int32_t(uint32_t(counter) + 1u); } _ZN12jsonrpc_fuzz10member_api5shiftERKNS_5pointE: 94| 634| point shift(const point& p) { return {p.x + 1, p.y + 1}; } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__16vectorIiNS1_9allocatorIiEEEEEEbOT_: 304| 146| { 305| 146|#ifdef __cpp_lib_ranges 306| 146| return std::ranges::empty(rng); 307| |#else 308| | // in lieu of std::ranges::empty 309| | if constexpr (requires() { 310| | { rng.empty() } -> std::convertible_to; 311| | }) { 312| | return rng.empty(); 313| | } 314| | else if constexpr (requires() { 315| | { rng.size() } -> std::same_as; 316| | }) { 317| | return rng.size() == std::size_t{0}; 318| | } 319| | else { 320| | return std::cbegin(rng) == std::cend(rng); 321| | } 322| |#endif 323| 146| } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEEEbOT_: 304| 100| { 305| 100|#ifdef __cpp_lib_ranges 306| 100| return std::ranges::empty(rng); 307| |#else 308| | // in lieu of std::ranges::empty 309| | if constexpr (requires() { 310| | { rng.empty() } -> std::convertible_to; 311| | }) { 312| | return rng.empty(); 313| | } 314| | else if constexpr (requires() { 315| | { rng.size() } -> std::same_as; 316| | }) { 317| | return rng.size() == std::size_t{0}; 318| | } 319| | else { 320| | return std::cbegin(rng) == std::cend(rng); 321| | } 322| |#endif 323| 100| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2Ev: 566| 1.10M| ordered_small_map() = default; _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9free_dataEv: 266| 3.00M| { 267| 3.00M| destroy_all(); 268| 3.00M| ::operator delete(data_); 269| 3.00M| data_ = nullptr; 270| 3.00M| size_ = 0; 271| 3.00M| capacity_ = 0; 272| 3.00M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11destroy_allEv: 259| 4.11M| { 260| 7.40M| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (260:31): [True: 3.29M, False: 4.11M] ------------------ 261| 3.29M| std::destroy_at(data_ + i); 262| 3.29M| } 263| 4.11M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10free_indexEv: 308| 3.00M| { 309| 3.00M| std::free(index_); 310| 3.00M| index_ = nullptr; 311| 3.00M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEC2EOS4_: 610| 1.90M| : data_(other.data_), size_(other.size_), capacity_(other.capacity_), index_(other.index_) 611| 1.90M| { 612| 1.90M| other.data_ = nullptr; 613| 1.90M| other.size_ = 0; 614| 1.90M| other.capacity_ = 0; 615| 1.90M| other.index_ = nullptr; 616| 1.90M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEED2Ev: 569| 3.00M| { 570| 3.00M| free_data(); 571| 3.00M| free_index(); 572| 3.00M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 932| 3.29M| { 933| 3.29M| return subscript_or_insert(key, [&] { emplace_back_impl(key, mapped_type{}); }); 934| 3.29M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19subscript_or_insertINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEZNS4_ixERKSC_EUlvE_EERS3_RKT_OT0_: 491| 3.29M| { 492| 3.29M| if (size_ <= linear_search_threshold) { ------------------ | Branch (492:14): [True: 3.29M, False: 180] ------------------ 493| 3.29M| auto it = linear_find(key); 494| 3.29M| if (it != end()) return it->second; ------------------ | Branch (494:17): [True: 0, False: 3.29M] ------------------ 495| 3.29M| append_fn(); 496| 3.29M| return data_[size_ - 1].second; 497| 3.29M| } 498| | 499| 180| const uint32_t h = hash_key(key); 500| 180| if (try_bloom_insert(h, append_fn)) { ------------------ | Branch (500:14): [True: 120, False: 60] ------------------ 501| 120| return data_[size_ - 1].second; 502| 120| } 503| | 504| 60| auto [it, pos, _] = index_find_or_pos(key, h); 505| 60| if (it != end()) return it->second; ------------------ | Branch (505:14): [True: 0, False: 60] ------------------ 506| | 507| 60| append_fn(); 508| 60| bloom_set(h); 509| 60| if (index_size() > 0) { ------------------ | Branch (509:14): [True: 60, False: 0] ------------------ 510| 60| const uint32_t n = index_->size; 511| 60| ensure_index_capacity(static_cast(n) + 1); 512| 60| auto* entries = index_entries(); 513| 60| if (pos < n) { ------------------ | Branch (513:17): [True: 0, False: 60] ------------------ 514| 0| std::memmove(entries + pos + 1, entries + pos, (n - pos) * sizeof(hash_index_entry)); 515| 0| } 516| 60| entries[pos] = {h, size_ - 1}; 517| 60| index_->size = size_; 518| 60| } 519| 60| return data_[size_ - 1].second; 520| 60| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11linear_findINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEPNS6_4pairISC_S3_EERKT_: 421| 3.29M| { 422| 6.55M| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (422:31): [True: 3.26M, False: 3.29M] ------------------ 423| 3.26M| if (data_[i].first == key) return data_ + i; ------------------ | Branch (423:17): [True: 0, False: 3.26M] ------------------ 424| 3.26M| } 425| 3.29M| return data_ + size_; 426| 3.29M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE3endEv: 649| 3.29M| iterator end() noexcept { return data_ + size_; } _ZZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEEixERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEENKUlvE_clEv: 933| 3.29M| 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| 3.29M| { 244| 3.29M| grow_if_needed(); 245| 3.29M| std::construct_at(data_ + size_, std::forward(args)...); 246| 3.29M| ++size_; 247| 3.29M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE14grow_if_neededEv: 217| 3.29M| { 218| 3.29M| if (size_ == capacity_) { ------------------ | Branch (218:14): [True: 1.10M, False: 2.18M] ------------------ 219| 1.10M| if (size_ == max_u32) { ------------------ | Branch (219:17): [True: 0, False: 1.10M] ------------------ 220| 0| throw_capacity_overflow(); 221| 0| } 222| 1.10M| const uint32_t new_cap = next_data_capacity(capacity_); 223| 1.10M| reallocate_data(new_cap); 224| 1.10M| } 225| 3.29M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE18next_data_capacityEj: 120| 1.10M| { 121| 1.10M| if (current == 0) return 4; ------------------ | Branch (121:14): [True: 1.10M, False: 120] ------------------ 122| 120| if (current > (max_u32 / 2)) return max_u32; ------------------ | Branch (122:14): [True: 0, False: 120] ------------------ 123| 120| return current * 2; 124| 120| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE15reallocate_dataEj: 205| 1.10M| { 206| 1.10M| if (new_cap < size_) { ------------------ | Branch (206:14): [True: 0, False: 1.10M] ------------------ 207| 0| throw_capacity_overflow(); 208| 0| } 209| 1.10M| auto* new_data = allocate_and_relocate(new_cap); 210| 1.10M| destroy_all(); 211| 1.10M| ::operator delete(data_); 212| 1.10M| data_ = new_data; 213| 1.10M| capacity_ = new_cap; 214| 1.10M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21allocate_and_relocateEj: 159| 1.10M| { 160| 1.10M| auto* new_data = static_cast(::operator new(checked_data_allocation_bytes(new_cap))); 161| 1.10M|#if __cpp_exceptions 162| 1.10M| uint32_t constructed = 0; 163| 1.10M| try { 164| 1.10M| for (; constructed < size_; ++constructed) { ------------------ | Branch (164:20): [True: 720, False: 1.10M] ------------------ 165| 720| std::construct_at(new_data + constructed, std::move_if_noexcept(data_[constructed])); 166| 720| } 167| 1.10M| } 168| 1.10M| 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| 1.10M| return new_data; 179| 1.10M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE29checked_data_allocation_bytesEj: 134| 1.10M| { 135| 1.10M| if (count > ((std::numeric_limits::max)() / sizeof(value_type))) { ------------------ | Branch (135:14): [True: 0, False: 1.10M] ------------------ 136| 0| GLZ_THROW_OR_ABORT(std::bad_alloc{}); ------------------ | | 8| 0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC)) ------------------ 137| 0| } 138| 1.10M| return static_cast(count) * sizeof(value_type); 139| 1.10M| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE8hash_keyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE: 97| 720| 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| 180| { 530| 180| if (index_ && size_ <= bloom_threshold && !bloom_maybe_contains(h)) { ------------------ | Branch (530:14): [True: 120, False: 60] | Branch (530:24): [True: 120, False: 0] | Branch (530:52): [True: 120, False: 0] ------------------ 531| | // Definitely not present — skip the search 532| 120| append_fn(); 533| 120| bloom_set(h); 534| | // Index is now stale (index_->size < size_), will rebuild on next lookup or false positive 535| 120| return true; 536| 120| } 537| 60| return false; 538| 180| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE20bloom_maybe_containsEj: 285| 120| { 286| 120| const uint32_t a = h & bloom_mask; 287| 120| const uint32_t b = (h >> 10) & bloom_mask; 288| 120| 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: 120] | Branch (288:70): [True: 0, False: 0] ------------------ 289| 120| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE17index_find_or_posINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEENS4_17index_find_resultERKT_j: 400| 60| { 401| 60| ensure_index(); 402| | 403| 60| const auto* base = index_entries(); 404| 60| const auto* idx_end = base + index_->size; 405| 60| const auto* p = branchless_lower_bound(base, index_->size, h); 406| 60| const size_t pos = static_cast(p - base); 407| | 408| | // Scan adjacent entries with matching hash 409| 60| for (auto* scan = p; scan != idx_end && scan->key_hash == h; ++scan) { ------------------ | Branch (409:31): [True: 0, False: 60] | 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| 60| return {data_ + size_, pos, h}; 416| 60| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE12ensure_indexEv: 360| 60| { 361| 60| if (size_ <= linear_search_threshold) return; ------------------ | Branch (361:14): [True: 0, False: 60] ------------------ 362| 60| const auto current = index_size(); 363| 60| if (current == size_) return; // fully current ------------------ | Branch (363:14): [True: 0, False: 60] ------------------ 364| | 365| 60| if (current == 0 || (size_ - current) > linear_search_threshold) { ------------------ | Branch (365:14): [True: 60, False: 0] | Branch (365:30): [True: 0, False: 0] ------------------ 366| 60| rebuild_index(); // full rebuild 367| 60| return; 368| 60| } 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| 60| { 344| 60| ensure_index_capacity(static_cast(size_)); 345| 60| bloom_clear(); 346| 60| auto* entries = index_entries(); 347| 600| for (uint32_t i = 0; i < size_; ++i) { ------------------ | Branch (347:31): [True: 540, False: 60] ------------------ 348| 540| const uint32_t h = hash_key(data_[i].first); 349| 540| entries[i] = {h, i}; 350| 540| bloom_set(h); 351| 540| } 352| 60| std::sort(entries, entries + size_, [](const auto& a, const auto& b) { return a.key_hash < b.key_hash; }); 353| 60| index_->size = size_; 354| 60| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE11bloom_clearEv: 291| 60| 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.50k| 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| 60| { 441| 300| while (len > 1) { ------------------ | Branch (441:17): [True: 240, False: 60] ------------------ 442| 240| size_t half = len / 2; 443| 240| p += (p[half - 1].key_hash < target) * half; 444| 240| len -= half; 445| 240| } 446| | // Final element check: advance past it if it's less than target 447| 60| p += (len == 1 && p->key_hash < target); ------------------ | Branch (447:16): [True: 60, False: 0] | Branch (447:28): [True: 60, False: 0] ------------------ 448| 60| return p; 449| 60| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE9bloom_setEj: 277| 720| { 278| 720| const uint32_t a = h & bloom_mask; 279| 720| const uint32_t b = (h >> 10) & bloom_mask; 280| 720| index_->bloom[a >> 3] |= uint8_t(1) << (a & 7); 281| 720| index_->bloom[b >> 3] |= uint8_t(1) << (b & 7); 282| 720| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE10index_sizeEv: 300| 120| uint32_t index_size() const noexcept { return index_ ? index_->size : 0; } ------------------ | Branch (300:53): [True: 60, False: 60] ------------------ _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE21ensure_index_capacityEm: 314| 120| { 315| 120| if (needed == 0) return; ------------------ | Branch (315:14): [True: 0, False: 120] ------------------ 316| 120| if (needed > static_cast(max_u32)) { ------------------ | Branch (316:14): [True: 0, False: 120] ------------------ 317| 0| throw_index_overflow(); 318| 0| } 319| 120| const auto needed_u32 = static_cast(needed); 320| 120| if (index_ && index_->capacity >= needed_u32) return; ------------------ | Branch (320:14): [True: 60, False: 60] | Branch (320:24): [True: 60, False: 0] ------------------ 321| 60| uint32_t cap = index_ ? index_->capacity : 0; ------------------ | Branch (321:25): [True: 0, False: 60] ------------------ 322| 120| while (cap < needed_u32) { ------------------ | Branch (322:17): [True: 60, False: 60] ------------------ 323| 60| const uint32_t next = next_index_capacity(cap); 324| 60| if (next <= cap) { ------------------ | Branch (324:17): [True: 0, False: 60] ------------------ 325| 0| throw_index_overflow(); 326| 0| } 327| 60| cap = next; 328| 60| } 329| 60| auto* block = static_cast(std::realloc(index_, checked_index_allocation_bytes(cap))); 330| 60| 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: 60] ------------------ 331| 60| if (!index_) { ------------------ | Branch (331:14): [True: 60, False: 0] ------------------ 332| 60| block->size = 0; 333| 60| std::memset(block->bloom, 0, bloom_bytes); 334| 60| } 335| 60| block->capacity = cap; 336| 60| index_ = block; 337| 60| } _ZN3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE19next_index_capacityEj: 127| 60| { 128| 60| if (current == 0) return 16; ------------------ | Branch (128:14): [True: 60, 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| 60| { 143| 60| constexpr size_t header = sizeof(index_header); 144| 60| constexpr size_t entry = sizeof(hash_index_entry); 145| 60| if (count > (((std::numeric_limits::max)() - header) / entry)) { ------------------ | Branch (145:14): [True: 0, False: 60] ------------------ 146| 0| GLZ_THROW_OR_ABORT(std::bad_alloc{}); ------------------ | | 8| 0|#define GLZ_THROW_OR_ABORT(EXC) (throw(EXC)) ------------------ 147| 0| } 148| 60| return header + static_cast(count) * entry; 149| 60| } _ZNK3glz17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES0_EEE13index_entriesEv: 296| 180| { 297| 180| return static_cast(static_cast(index_ + 1)); 298| 180| } _ZN3glz15resize_unfilledINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m: 63| 9.31M| { 64| 9.31M| if constexpr (requires { b.resize_and_overwrite(n, [](auto*, size_t written) { return written; }); }) { 65| 9.31M| b.resize_and_overwrite(n, [](auto*, size_t written) noexcept { return written; }); 66| | } 67| | else { 68| | b.resize(n); 69| | } 70| 9.31M| } _ZZN3glz15resize_unfilledINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_mENKUlPS8_mE_clIcEEDaSA_m: 65| 9.31M| b.resize_and_overwrite(n, [](auto*, size_t written) noexcept { return written; }); _ZN3glz12ensure_spaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_RT_m: 265| 4.36M| { 266| 4.36M| using Buffer = std::remove_cvref_t; 267| | 268| 4.36M| if constexpr (vector_like) { 269| 4.36M| if (required > b.size()) [[unlikely]] { ------------------ | Branch (269:14): [True: 1.23k, False: 4.36M] ------------------ 270| 1.23k| grow_buffer(b, required); 271| 1.23k| } 272| 4.36M| return true; 273| | } 274| | else if constexpr (has_bounded_capacity) { 275| | if (required > buffer_traits::capacity(b)) [[unlikely]] { 276| | ctx.error = error_code::buffer_overflow; 277| | return false; 278| | } 279| | return true; 280| | } 281| | else { 282| | return true; // Raw pointer or other - trust caller 283| | } 284| 4.36M| } _ZN3glz11grow_bufferINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRT_m: 143| 1.23k| { 144| 1.23k| using traits = buffer_traits>; 145| 1.23k| if constexpr (requires { traits::grow(b, required); }) { 146| 1.23k| traits::grow(b, required); 147| | } 148| | else { 149| | // A user specialization written before `grow` existed: keep the growth it used to get. 150| | resize_unfilled(b, 2 * required); 151| | } 152| 1.23k| } _ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE4growERS7_mQL_ZNS_13buffer_traits12is_resizableEE: 118| 1.23k| { 119| 1.23k| resize_unfilled(b, 2 * required); 120| 1.23k| } _ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE8finalizeERS7_m: 124| 4.36M| { 125| 4.36M| if constexpr (is_resizable) { 126| 4.36M| b.resize(written); 127| 4.36M| } 128| | // For fixed buffers: no-op, count is returned in result 129| 4.36M| } _ZN3glz20inert_key_bits_scopeC2IRNS_7contextEEEOT_Pv: 192| 1.27M| constexpr inert_key_bits_scope(auto&&, void*) noexcept {} _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_iEEDcOT_OT0_: 677| 79.7k| { 678| 79.7k| using V = std::decay_t; 679| 79.7k| if constexpr (std::is_member_object_pointer_v) { 680| 79.7k| return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 79.7k| } _ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_EENS1_17basic_string_viewIcS4_EEOT0_: 341| 45.1k| { 342| | if constexpr (std::same_as, std::string_view>) { 343| | return value; // already the answer; rebuilding it from data() and size() costs instructions 344| | } 345| | else if constexpr (!char_array_t && std::is_pointer_v>) { 346| | return value ? std::string_view{value} : std::string_view{}; 347| | } 348| 45.1k| else if constexpr (has_data && has_size) { 349| 45.1k| return std::string_view{value.data(), value.size()}; 350| | } 351| | else { 352| | return std::string_view{value}; 353| | } 354| 45.1k| } _ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERS5_EES5_OT0_: 341| 5.88k| { 342| 5.88k| if constexpr (std::same_as, std::string_view>) { 343| 5.88k| return value; // already the answer; rebuilding it from data() and size() costs instructions 344| | } 345| | else if constexpr (!char_array_t && std::is_pointer_v>) { 346| | return value ? std::string_view{value} : std::string_view{}; 347| | } 348| | else if constexpr (has_data && has_size) { 349| | return std::string_view{value.data(), value.size()}; 350| | } 351| | else { 352| | return std::string_view{value}; 353| | } 354| 5.88k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FiiEEEDcOT_OT0_: 677| 79.7k| { 678| 79.7k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| 79.7k| else if constexpr (std::is_member_function_pointer_v) { 683| 79.7k| return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 79.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FvvEEEDcOT_OT0_: 677| 79.7k| { 678| 79.7k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| 79.7k| else if constexpr (std::is_member_function_pointer_v) { 683| 79.7k| return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 79.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz10member_apiERKMS2_FNS1_5pointERKS4_EEEDcOT_OT0_: 677| 79.7k| { 678| 79.7k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| 79.7k| else if constexpr (std::is_member_function_pointer_v) { 683| 79.7k| return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 79.7k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz5pointERdEEDcOT_OT0_: 677| 167k| { 678| 167k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 167k| else { 700| 167k| return element; 701| 167k| } 702| 167k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERiEEDcOT_OT0_: 677| 97.2k| { 678| 97.2k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 97.2k| else { 700| 97.2k| return element; 701| 97.2k| } 702| 97.2k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 677| 79.8k| { 678| 79.8k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 79.8k| else { 700| 79.8k| return element; 701| 79.8k| } 702| 79.8k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_5pointEEEDcOT_OT0_: 677| 80.6k| { 678| 80.6k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.6k| else { 700| 80.6k| return element; 701| 80.6k| } 702| 80.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERiEEDcOT_OT0_: 677| 95.4k| { 678| 95.4k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 95.4k| else { 700| 95.4k| return element; 701| 95.4k| } 702| 95.4k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6nestedERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 677| 80.6k| { 678| 80.6k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.6k| else { 700| 80.6k| return element; 701| 80.6k| } 702| 80.6k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNS1_6nestedEEEDcOT_OT0_: 677| 80.5k| { 678| 80.5k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.5k| else { 700| 80.5k| return element; 701| 80.5k| } 702| 80.5k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__16vectorIiNS4_9allocatorIiEEEEEEDcOT_OT0_: 677| 88.0k| { 678| 88.0k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 88.0k| else { 700| 88.0k| return element; 701| 88.0k| } 702| 88.0k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEEEEDcOT_OT0_: 677| 81.0k| { 678| 81.0k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 81.0k| else { 700| 81.0k| return element; 701| 81.0k| } 702| 81.0k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18optionalIdEEEEDcOT_OT0_: 677| 81.2k| { 678| 81.2k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 81.2k| else { 700| 81.2k| return element; 701| 81.2k| } 702| 81.2k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz6amountERdEEDcOT_OT0_: 677| 329| { 678| 329| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 329| else { 700| 329| return element; 701| 329| } 702| 329| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_6amountEEEEEEDcOT_OT0_: 677| 81.1k| { 678| 81.1k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 81.1k| else { 700| 81.1k| return element; 701| 81.1k| } 702| 81.1k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFiiEEEEEDcOT_OT0_: 677| 80.1k| { 678| 80.1k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.1k| else { 700| 80.1k| return element; 701| 80.1k| } 702| 80.1k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEEEEDcOT_OT0_: 677| 80.2k| { 678| 80.2k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.2k| else { 700| 80.2k| return element; 701| 80.2k| } 702| 80.2k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFNS1_5pointERKS6_EEEEEDcOT_OT0_: 677| 80.1k| { 678| 80.1k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.1k| else { 700| 80.1k| return element; 701| 80.1k| } 702| 80.1k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEEEEDcOT_OT0_: 677| 80.1k| { 678| 80.1k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.1k| else { 700| 80.1k| return element; 701| 80.1k| } 702| 80.1k| } _ZN3glz10get_memberIRN12jsonrpc_fuzz8fuzz_apiERNSt3__18functionIFvvEEEEEDcOT_OT0_: 677| 80.0k| { 678| 80.0k| using V = std::decay_t; 679| | if constexpr (std::is_member_object_pointer_v) { 680| | return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| 80.0k| else { 700| 80.0k| return element; 701| 80.0k| } 702| 80.0k| } _ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_EENS1_17basic_string_viewIcS4_EEOT0_: 341| 4.27M| { 342| | if constexpr (std::same_as, std::string_view>) { 343| | return value; // already the answer; rebuilding it from data() and size() costs instructions 344| | } 345| | else if constexpr (!char_array_t && std::is_pointer_v>) { 346| | return value ? std::string_view{value} : std::string_view{}; 347| | } 348| 4.27M| else if constexpr (has_data && has_size) { 349| 4.27M| return std::string_view{value.data(), value.size()}; 350| | } 351| | else { 352| | return std::string_view{value}; 353| | } 354| 4.27M| } _ZN3glz14basic_raw_jsonINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEC2Ev: 231| 9.22M| basic_raw_json() = default; _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__18optionalINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEEEEDcOT_OT0_: 677| 137k| { 678| 137k| using V = std::decay_t; 679| 137k| if constexpr (std::is_member_object_pointer_v) { 680| 137k| return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 137k| } _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEEEDcOT_OT0_: 677| 46.0k| { 678| 46.0k| using V = std::decay_t; 679| 46.0k| if constexpr (std::is_member_object_pointer_v) { 680| 46.0k| return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 46.0k| } _ZN3glz10get_memberIRNS_3rpc18request_envelope_tERKMS2_NSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEEEEDcOT_OT0_: 677| 83.6k| { 678| 83.6k| using V = std::decay_t; 679| 83.6k| if constexpr (std::is_member_object_pointer_v) { 680| 83.6k| return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 83.6k| } _ZN3glz8str_viewINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKS5_EES5_OT0_: 341| 70| { 342| 70| if constexpr (std::same_as, std::string_view>) { 343| 70| return value; // already the answer; rebuilding it from data() and size() costs instructions 344| | } 345| | else if constexpr (!char_array_t && std::is_pointer_v>) { 346| | return value ? std::string_view{value} : std::string_view{}; 347| | } 348| | else if constexpr (has_data && has_size) { 349| | return std::string_view{value.data(), value.size()}; 350| | } 351| | else { 352| | return std::string_view{value}; 353| | } 354| 70| } _ZN3glz10get_memberIRNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEERKMS4_NSt3__17variantIJDndNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEbNS6_6vectorIS4_NSB_IS4_EEEENS3_IS4_EEEEEEEDcOT_OT0_: 677| 3.86M| { 678| 3.86M| using V = std::decay_t; 679| 3.86M| if constexpr (std::is_member_object_pointer_v) { 680| 3.86M| return value.*element; 681| | } 682| | else if constexpr (std::is_member_function_pointer_v) { 683| | return element; 684| | } 685| | else if constexpr (std::invocable && not eigen_t) { 686| | // Eigen places a static_assert inside of the operator()(), so we must target 687| | // matrix types and reject them from the invocable check 688| | // Eigen ought to put the check in the `enable_if` for operator()() 689| | return std::invoke(std::forward(element), std::forward(value)); 690| | } 691| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 692| | if constexpr (std::invocable) { 693| | return std::invoke(*element, std::forward(value)); 694| | } 695| | else { 696| | return *element; 697| | } 698| | } 699| | else { 700| | return element; 701| | } 702| 3.86M| } _ZN3glz10call_scopeINS_7contextEEC2ERS1_: 272| 13.0M| explicit call_scope(Ctx& c) noexcept : ctx(c), depth(c.depth) 273| 13.0M| { 274| 13.0M| ctx.error = error_code::none; 275| 13.0M| ctx.custom_error_message = {}; 276| 13.0M| } _ZN3glz11enter_depthITkNS_10is_contextENS_7contextEEEbRT_: 344| 1.67M| { 345| 1.67M| if (ctx.depth >= max_recursive_depth_limit) [[unlikely]] { ------------------ | Branch (345:11): [True: 498, False: 1.67M] ------------------ 346| 498| ctx.error = error_code::exceeded_max_recursive_depth; 347| 498| return true; 348| 498| } 349| 1.67M| ++ctx.depth; 350| 1.67M| return false; 351| 1.67M| } _ZN3glz10call_scopeINS_7contextEED2Ev: 277| 13.0M| ~call_scope() { ctx.depth = depth; } _ZNK3glz9error_ctxcvbEv: 148| 13.0M| operator bool() const noexcept { return ec != error_code::none; } _ZN3glz18charge_speculationITkNS_10is_contextENS_7contextEEEbRT_m: 311| 55.9k| { 312| 55.9k| if constexpr (requires { ctx.speculation_budget; }) { 313| 55.9k| if (ctx.speculation_budget == 0) { ------------------ | Branch (313:14): [True: 0, False: 55.9k] ------------------ 314| 0| return true; 315| 0| } 316| 55.9k| ctx.speculation_budget = consumed >= ctx.speculation_budget ? 1 : ctx.speculation_budget - consumed; ------------------ | Branch (316:35): [True: 0, False: 55.9k] ------------------ 317| 55.9k| return ctx.speculation_budget > 1; 318| | } 319| | else { 320| | return true; 321| | } 322| 55.9k| } _ZN3glz21speculation_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 328| 3.20k| { 329| 3.20k| if constexpr (requires { ctx.speculation_budget; }) { 330| 3.20k| return ctx.speculation_budget == 1; // the latched floor; 0 means unbudgeted 331| | } 332| | else { 333| | return false; 334| | } 335| 3.20k| } _ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEDaOT0_: 40| 543k| { 41| 543k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 543k| auto it = reinterpret_cast(buffer.data()); 44| 543k| auto end = it + buffer.size(); 45| | 46| 543k| return std::pair{it, end}; 47| 543k| } _ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_: 131| 468k| { 132| 468k| if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) { 133| | // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every 134| | // successful read, which is the ordinary case for a registry parsing a wire span. 135| | // start < it, not !=, because a streaming origin can be empty or overshoot on an error 136| | // path; neither is an absent value. 137| 468k| if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) { ------------------ | Branch (137:14): [True: 101k, False: 367k] | Branch (137:54): [True: 100k, False: 920] | Branch (137:72): [True: 97.7k, False: 2.92k] | Branch (137:85): [True: 97.7k, False: 0] ------------------ 138| 97.7k| context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused 139| 97.7k| const char* consumed = start; 140| 97.7k| skip_ws(ws_ctx, consumed, it); 141| 97.7k| if (consumed == it) { ------------------ | Branch (141:17): [True: 14, False: 97.7k] ------------------ 142| 14| ctx.error = error_code::no_read_input; 143| 14| } 144| 97.7k| } 145| 468k| } 146| 468k| finalize_read_context(ctx); 147| 468k| } _ZN3glz21finalize_read_contextITkNS_10is_contextERNS_7contextEEEvOT_: 109| 721k| { 110| 721k| settle_partial_read_complete(ctx); 111| 721k| settle_end_reached(ctx); 112| 721k| } _ZN3glz28settle_partial_read_completeITkNS_10is_contextERNS_7contextEEEvOT_: 102| 721k| { 103| 721k| if (ctx.error == error_code::partial_read_complete) { ------------------ | Branch (103:11): [True: 0, False: 721k] ------------------ 104| 0| ctx.error = error_code::none; 105| 0| } 106| 721k| } _ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_: 88| 721k| { 89| 721k| if (ctx.error == error_code::end_reached) { ------------------ | Branch (89:11): [True: 131k, False: 590k] ------------------ 90| 131k| ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end; ------------------ | Branch (90:22): [True: 130k, False: 1.14k] ------------------ 91| 131k| } 92| 721k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_: 232| 1.37k| { 233| 1.37k| format_context_t ctx{}; 234| 1.37k| return read(value, buffer, ctx); 235| 1.37k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_: 152| 1.37k| { 153| 1.37k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.37k| call_scope scope{ctx}; 156| | 157| 1.37k| if constexpr (Opts.format != NDJSON) { 158| 1.37k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.37k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.37k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.37k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.37k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.37k| auto [it, end] = read_iterators(buffer); 178| 1.37k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.37k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.37k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.37k| ctx.speculation_budget = 185| 1.37k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 13, False: 1.36k] ------------------ 186| 1.37k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.37k| parse::template op(value, ctx, it, end); 201| | 202| 1.37k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.27k, False: 106] ------------------ 203| 1.27k| goto finish; 204| 1.27k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.37k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.37k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.37k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 106| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 232| 1.42k| { 233| 1.42k| format_context_t ctx{}; 234| 1.42k| return read(value, buffer, ctx); 235| 1.42k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 152| 1.42k| { 153| 1.42k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.42k| call_scope scope{ctx}; 156| | 157| 1.42k| if constexpr (Opts.format != NDJSON) { 158| 1.42k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.42k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.42k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.42k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.42k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.42k| auto [it, end] = read_iterators(buffer); 178| 1.42k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.42k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.42k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.42k| ctx.speculation_budget = 185| 1.42k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 3, False: 1.42k] ------------------ 186| 1.42k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.42k| parse::template op(value, ctx, it, end); 201| | 202| 1.42k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.42k, False: 0] ------------------ 203| 1.42k| goto finish; 204| 1.42k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.42k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.42k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.42k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 232| 8.99k| { 233| 8.99k| format_context_t ctx{}; 234| 8.99k| return read(value, buffer, ctx); 235| 8.99k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 152| 8.99k| { 153| 8.99k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 8.99k| call_scope scope{ctx}; 156| | 157| 8.99k| if constexpr (Opts.format != NDJSON) { 158| 8.99k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 8.99k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 8.99k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 8.99k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 8.99k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 8.99k| auto [it, end] = read_iterators(buffer); 178| 8.99k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 8.99k| if constexpr (requires { ctx.speculation_budget; }) { 183| 8.99k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 8.99k| ctx.speculation_budget = 185| 8.99k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 116, False: 8.87k] ------------------ 186| 8.99k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 8.99k| parse::template op(value, ctx, it, end); 201| | 202| 8.99k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 8.99k, False: 0] ------------------ 203| 8.99k| goto finish; 204| 8.99k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 8.99k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 8.99k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 8.99k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10contiguousERNS2_17basic_string_viewIcS5_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 232| 1.53k| { 233| 1.53k| format_context_t ctx{}; 234| 1.53k| return read(value, buffer, ctx); 235| 1.53k| } _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_: 152| 1.53k| { 153| 1.53k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.53k| call_scope scope{ctx}; 156| | 157| 1.53k| if constexpr (Opts.format != NDJSON) { 158| 1.53k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.53k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.53k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.53k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.53k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.53k| auto [it, end] = read_iterators(buffer); 178| 1.53k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.53k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.53k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.53k| ctx.speculation_budget = 185| 1.53k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 53, False: 1.48k] ------------------ 186| 1.53k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.53k| parse::template op(value, ctx, it, end); 201| | 202| 1.53k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 992, False: 547] ------------------ 203| 992| goto finish; 204| 992| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.53k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.53k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.53k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 547| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERS8_OS9_: 232| 736| { 233| 736| format_context_t ctx{}; 234| 736| return read(value, buffer, ctx); 235| 736| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEdTkNS_10contiguousERNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_OT2_: 152| 736| { 153| 736| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 736| call_scope scope{ctx}; 156| | 157| 736| if constexpr (Opts.format != NDJSON) { 158| 736| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 736] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 736| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 736| ctx.padded_input = check_is_padded(Opts); 174| | 175| 736| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 736| auto [it, end] = read_iterators(buffer); 178| 736| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 736| if constexpr (requires { ctx.speculation_budget; }) { 183| 736| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 736| ctx.speculation_budget = 185| 736| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 3, False: 733] ------------------ 186| 736| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 736| parse::template op(value, ctx, it, end); 201| | 202| 736| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 684, False: 52] ------------------ 203| 684| goto finish; 204| 684| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 736| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 736| finalize_top_level_read(ctx, start, it, end); 225| | 226| 736| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 52| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 232| 1.81k| { 233| 1.81k| format_context_t ctx{}; 234| 1.81k| return read(value, buffer, ctx); 235| 1.81k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 152| 1.81k| { 153| 1.81k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.81k| call_scope scope{ctx}; 156| | 157| 1.81k| if constexpr (Opts.format != NDJSON) { 158| 1.81k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.81k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.81k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.81k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.81k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.81k| auto [it, end] = read_iterators(buffer); 178| 1.81k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.81k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.81k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.81k| ctx.speculation_budget = 185| 1.81k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 21, False: 1.78k] ------------------ 186| 1.81k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.81k| parse::template op(value, ctx, it, end); 201| | 202| 1.81k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.81k, False: 0] ------------------ 203| 1.81k| goto finish; 204| 1.81k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.81k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.81k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.81k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 232| 1.93k| { 233| 1.93k| format_context_t ctx{}; 234| 1.93k| return read(value, buffer, ctx); 235| 1.93k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIiNS2_9allocatorIiEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 152| 1.93k| { 153| 1.93k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.93k| call_scope scope{ctx}; 156| | 157| 1.93k| if constexpr (Opts.format != NDJSON) { 158| 1.93k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.93k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.93k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.93k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.93k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.93k| auto [it, end] = read_iterators(buffer); 178| 1.93k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.93k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.93k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.93k| ctx.speculation_budget = 185| 1.93k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 24, False: 1.90k] ------------------ 186| 1.93k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.93k| parse::template op(value, ctx, it, end); 201| | 202| 1.93k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.49k, False: 442] ------------------ 203| 1.49k| goto finish; 204| 1.49k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.93k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.93k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.93k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 442| } _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_: 232| 1.64k| { 233| 1.64k| format_context_t ctx{}; 234| 1.64k| return read(value, buffer, ctx); 235| 1.64k| } _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_: 152| 1.64k| { 153| 1.64k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.64k| call_scope scope{ctx}; 156| | 157| 1.64k| if constexpr (Opts.format != NDJSON) { 158| 1.64k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.64k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.64k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.64k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.64k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.64k| auto [it, end] = read_iterators(buffer); 178| 1.64k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.64k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.64k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.64k| ctx.speculation_budget = 185| 1.64k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 10, False: 1.63k] ------------------ 186| 1.64k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.64k| parse::template op(value, ctx, it, end); 201| | 202| 1.64k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.64k, False: 0] ------------------ 203| 1.64k| goto finish; 204| 1.64k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.64k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.64k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.64k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 0| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 232| 2.15k| { 233| 2.15k| format_context_t ctx{}; 234| 2.15k| return read(value, buffer, ctx); 235| 2.15k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__18optionalIdEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 152| 2.15k| { 153| 2.15k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 2.15k| call_scope scope{ctx}; 156| | 157| 2.15k| if constexpr (Opts.format != NDJSON) { 158| 2.15k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 2.15k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 2.15k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 2.15k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 2.15k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 2.15k| auto [it, end] = read_iterators(buffer); 178| 2.15k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 2.15k| if constexpr (requires { ctx.speculation_budget; }) { 183| 2.15k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 2.15k| ctx.speculation_budget = 185| 2.15k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 36, False: 2.11k] ------------------ 186| 2.15k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 2.15k| parse::template op(value, ctx, it, end); 201| | 202| 2.15k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 2.00k, False: 153] ------------------ 203| 2.00k| goto finish; 204| 2.00k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 2.15k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 2.15k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 2.15k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 153| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10contiguousERNS2_17basic_string_viewIcS6_EEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_: 232| 1.29k| { 233| 1.29k| format_context_t ctx{}; 234| 1.29k| return read(value, buffer, ctx); 235| 1.29k| } _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_: 152| 1.29k| { 153| 1.29k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 1.29k| call_scope scope{ctx}; 156| | 157| 1.29k| if constexpr (Opts.format != NDJSON) { 158| 1.29k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 1.29k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 1.29k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 1.29k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 1.29k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 1.29k| auto [it, end] = read_iterators(buffer); 178| 1.29k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 1.29k| if constexpr (requires { ctx.speculation_budget; }) { 183| 1.29k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 1.29k| ctx.speculation_budget = 185| 1.29k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 27, False: 1.27k] ------------------ 186| 1.29k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 1.29k| parse::template op(value, ctx, it, end); 201| | 202| 1.29k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 876, False: 423] ------------------ 203| 876| goto finish; 204| 876| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 1.29k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 1.29k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 1.29k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 423| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_: 232| 3.62k| { 233| 3.62k| format_context_t ctx{}; 234| 3.62k| return read(value, buffer, ctx); 235| 3.62k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorIdNS2_9allocatorIdEEEETkNS_10contiguousERNS2_17basic_string_viewIcNS2_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_OT2_: 152| 3.62k| { 153| 3.62k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 3.62k| call_scope scope{ctx}; 156| | 157| 3.62k| if constexpr (Opts.format != NDJSON) { 158| 3.62k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 3.62k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 3.62k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 3.62k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 3.62k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 3.62k| auto [it, end] = read_iterators(buffer); 178| 3.62k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 3.62k| if constexpr (requires { ctx.speculation_budget; }) { 183| 3.62k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 3.62k| ctx.speculation_budget = 185| 3.62k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 44, False: 3.57k] ------------------ 186| 3.62k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 3.62k| parse::template op(value, ctx, it, end); 201| | 202| 3.62k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 1.77k, False: 1.84k] ------------------ 203| 1.77k| goto finish; 204| 1.77k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 3.62k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 3.62k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 3.62k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 1.84k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__16vectorINS_14basic_raw_jsonINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_9allocatorIS9_EEEETkNS_10contiguousERS8_Qaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSE_OSF_: 232| 30.5k| { 233| 30.5k| format_context_t ctx{}; 234| 30.5k| return read(value, buffer, ctx); 235| 30.5k| } _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_: 152| 30.5k| { 153| 30.5k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 30.5k| call_scope scope{ctx}; 156| | 157| 30.5k| if constexpr (Opts.format != NDJSON) { 158| 30.5k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 30.5k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 30.5k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 30.5k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 30.5k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 30.5k| auto [it, end] = read_iterators(buffer); 178| 30.5k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 30.5k| if constexpr (requires { ctx.speculation_budget; }) { 183| 30.5k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 30.5k| ctx.speculation_budget = 185| 30.5k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 703, False: 29.8k] ------------------ 186| 30.5k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 30.5k| parse::template op(value, ctx, it, end); 201| | 202| 30.5k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 9.92k, False: 20.6k] ------------------ 203| 9.92k| goto finish; 204| 9.92k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 30.5k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 30.5k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 30.5k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 20.6k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSA_OSB_: 232| 4.32M| { 233| 4.32M| format_context_t ctx{}; 234| 4.32M| return read(value, buffer, ctx); 235| 4.32M| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSC_OSD_OT2_: 152| 4.32M| { 153| 4.32M| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 4.32M| call_scope scope{ctx}; 156| | 157| 4.32M| if constexpr (Opts.format != NDJSON) { 158| 4.32M| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 4.00M, False: 315k] ------------------ 159| 4.00M| ctx.error = error_code::no_read_input; 160| 4.00M| return {0, ctx.error, ctx.custom_error_message}; 161| 4.00M| } 162| 4.32M| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 315k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 4.32M| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 4.32M| auto [it, end] = read_iterators(buffer); 178| 4.32M| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 4.32M| if constexpr (requires { ctx.speculation_budget; }) { 183| 4.32M| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 4.32M| ctx.speculation_budget = 185| 4.32M| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 1.30k, False: 4.32M] ------------------ 186| 4.32M| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 4.32M| parse::template op(value, ctx, it, end); 201| | 202| 4.32M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 310k, False: 4.01M] ------------------ 203| 310k| goto finish; 204| 310k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 4.01M| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 315k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 315k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 4.01M| } _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_: 152| 4.25M| { 153| 4.25M| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 4.25M| call_scope scope{ctx}; 156| | 157| 4.25M| if constexpr (Opts.format != NDJSON) { 158| 4.25M| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 4.00M, False: 252k] ------------------ 159| 4.00M| ctx.error = error_code::no_read_input; 160| 4.00M| return {0, ctx.error, ctx.custom_error_message}; 161| 4.00M| } 162| 4.25M| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 252k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 4.25M| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 4.25M| auto [it, end] = read_iterators(buffer); 178| 4.25M| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 4.25M| if constexpr (requires { ctx.speculation_budget; }) { 183| 4.25M| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 4.25M| ctx.speculation_budget = 185| 4.25M| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 757, False: 4.25M] ------------------ 186| 4.25M| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 4.25M| parse::template op(value, ctx, it, end); 201| | 202| 4.25M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 181k, False: 4.07M] ------------------ 203| 181k| goto finish; 204| 181k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| 4.07M| if constexpr (check_validate_trailing_whitespace(Opts)) { 210| 4.07M| if (it < end) { ------------------ | Branch (210:14): [True: 5.68k, False: 4.07M] ------------------ 211| 5.68k| skip_ws(ctx, it, end); 212| 5.68k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (212:17): [True: 394, False: 5.29k] ------------------ 213| 394| goto finish; 214| 394| } 215| 5.29k| if (it != end) [[unlikely]] { ------------------ | Branch (215:17): [True: 5.29k, False: 0] ------------------ 216| 5.29k| ctx.error = error_code::syntax_error; 217| 5.29k| } 218| 5.29k| } 219| 4.07M| } 220| | 221| 4.07M| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 252k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 252k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 4.07M| } _ZN3glz14read_iteratorsITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEDaOT0_: 40| 252k| { 41| 252k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 252k| auto it = reinterpret_cast(buffer.data()); 44| 252k| auto end = it + buffer.size(); 45| | 46| 252k| return std::pair{it, end}; 47| 252k| } _ZN3glz23finalize_top_level_readITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS9_S9_: 131| 252k| { 132| 252k| if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) { 133| | // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every 134| | // successful read, which is the ordinary case for a registry parsing a wire span. 135| | // start < it, not !=, because a streaming origin can be empty or overshoot on an error 136| | // path; neither is an absent value. 137| 252k| if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) { ------------------ | Branch (137:14): [True: 30.2k, False: 222k] | Branch (137:54): [True: 29.9k, False: 225] | Branch (137:72): [True: 29.9k, False: 0] | Branch (137:85): [True: 29.9k, False: 0] ------------------ 138| 29.9k| context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused 139| 29.9k| const char* consumed = start; 140| 29.9k| skip_ws(ws_ctx, consumed, it); 141| 29.9k| if (consumed == it) { ------------------ | Branch (141:17): [True: 14, False: 29.9k] ------------------ 142| 14| ctx.error = error_code::no_read_input; 143| 14| } 144| 29.9k| } 145| 252k| } 146| 252k| finalize_read_context(ctx); 147| 252k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEETkNS_10contiguousERKNS2_4spanIKcLm18446744073709551615EEETkNS_10is_contextERNS_7contextEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSG_OSH_OT2_: 152| 20.6k| { 153| 20.6k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 20.6k| call_scope scope{ctx}; 156| | 157| 20.6k| if constexpr (Opts.format != NDJSON) { 158| 20.6k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 20.6k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 20.6k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 20.6k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 20.6k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 20.6k| auto [it, end] = read_iterators(buffer); 178| 20.6k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 20.6k| if constexpr (requires { ctx.speculation_budget; }) { 183| 20.6k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 20.6k| ctx.speculation_budget = 185| 20.6k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 55, False: 20.6k] ------------------ 186| 20.6k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 20.6k| parse::template op(value, ctx, it, end); 201| | 202| 20.6k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 17.5k, False: 3.16k] ------------------ 203| 17.5k| goto finish; 204| 17.5k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 20.6k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 20.6k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 20.6k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 3.16k| } _ZN3glz14read_iteratorsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERKNSt3__14spanIKcLm18446744073709551615EEEEEDaOT0_: 40| 20.6k| { 41| 20.6k| static_assert(sizeof(decltype(*buffer.data())) == 1); 42| | 43| 20.6k| auto it = reinterpret_cast(buffer.data()); 44| 20.6k| auto end = it + buffer.size(); 45| | 46| 20.6k| return std::pair{it, end}; 47| 20.6k| } _ZN3glz4readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10contiguousENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEQaa14read_supportedIT0_XdtT_6formatEEnt18is_input_streamingIT1_EEENS_9error_ctxERSB_OSC_: 232| 75.5k| { 233| 75.5k| format_context_t ctx{}; 234| 75.5k| return read(value, buffer, ctx); 235| 75.5k| } _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_: 152| 75.5k| { 153| 75.5k| static_assert(sizeof(decltype(*buffer.data())) == 1); 154| | 155| 75.5k| call_scope scope{ctx}; 156| | 157| 75.5k| if constexpr (Opts.format != NDJSON) { 158| 75.5k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (158:14): [True: 0, False: 75.5k] ------------------ 159| 0| ctx.error = error_code::no_read_input; 160| 0| return {0, ctx.error, ctx.custom_error_message}; 161| 0| } 162| 75.5k| } 163| | 164| | // The reader used to grow the caller's buffer by `padding_bytes` here and shrink it back on 165| | // the way out, so that its fixed width loads could run off the end of the document into 166| | // defined bytes. Every one of those loads is now bounded against `end` instead (see 167| | // `chunk_min`), which costs the last chunk of the buffer its chunked path and nothing else -- 168| | // measurably less than the round trip did. `std::string::resize` is an ABI entry point on 169| | // both libc++ and libstdc++, so neither call inlined and the parse was spilled around both 170| | // for what amounted to a sixteen byte store; the price did not scale with the document, so on 171| | // a small one it was the bulk of the call. A caller who does have that slack can still say so 172| | // and get the unbounded loads back, and nobody else pays for the buffer being touched at all. 173| 75.5k| ctx.padded_input = check_is_padded(Opts); 174| | 175| 75.5k| static constexpr auto ParseOpts = parse_opts_for(); 176| | 177| 75.5k| auto [it, end] = read_iterators(buffer); 178| 75.5k| auto start = it; 179| | 180| | // Bound the speculative re-parsing a variant resolution may do, in bytes, relative to this 181| | // input. Seeded per read so a reused context starts fresh. See charge_speculation. 182| 75.5k| if constexpr (requires { ctx.speculation_budget; }) { 183| 75.5k| const size_t proportional = max_speculative_parse_factor * size_t(end - it); 184| 75.5k| ctx.speculation_budget = 185| 75.5k| (proportional > min_speculative_parse_bytes ? proportional : min_speculative_parse_bytes) + 2; ------------------ | Branch (185:14): [True: 283, False: 75.3k] ------------------ 186| 75.5k| } 187| | 188| | // A YAML context marks its outermost parse with stream_begin and seeds its expansion budgets 189| | // there, so clearing it here is what makes those budgets per-read like the one above. A 190| | // reused context would otherwise carry a spent budget into the next document and reject a 191| | // valid one, and would leave stream_begin pointing into the buffer of the previous read. 192| | // Nested YAML parses do not route through glz::read, so they still cannot reseed themselves. 193| | if constexpr (requires { ctx.stream_begin; }) { 194| | ctx.stream_begin = nullptr; 195| | } 196| | 197| | // Normalized off before dispatching: no reader branches on it any more, so leaving it set 198| | // would split every instantiation below between callers who declared padding and callers who 199| | // did not, for a flag none of them reads. 200| 75.5k| parse::template op(value, ctx, it, end); 201| | 202| 75.5k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (202:11): [True: 61.4k, False: 14.1k] ------------------ 203| 61.4k| goto finish; 204| 61.4k| } 205| | 206| | // The JSON RFC 8259 defines: JSON-text = ws value ws 207| | // So, trailing whitespace is permitted and sometimes we want to 208| | // validate this, even though this memory will not affect Glaze. 209| | if constexpr (check_validate_trailing_whitespace(Opts)) { 210| | if (it < end) { 211| | skip_ws(ctx, it, end); 212| | if (bool(ctx.error)) [[unlikely]] { 213| | goto finish; 214| | } 215| | if (it != end) [[unlikely]] { 216| | ctx.error = error_code::syntax_error; 217| | } 218| | } 219| | } 220| | 221| 75.5k| finish: 222| | // ParseOpts, not Opts: this reads `null_terminated` to tell a value that ended with the 223| | // buffer from one that ran out, and it has to be told the same thing the parse was. 224| 75.5k| finalize_top_level_read(ctx, start, it, end); 225| | 226| 75.5k| return {size_t(it - start), ctx.error, ctx.custom_error_message}; 227| 14.1k| } _ZN3glz12format_errorINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKNS_9error_ctxERKT_: 3431| 4.28M| { 3432| 4.28M| const auto error_type_str = meta::keys[uint32_t(pe.ec)]; 3433| | 3434| 4.28M| const auto info = detail::get_source_info(buffer, pe.count); 3435| 4.28M| auto error_str = detail::generate_error_string(error_type_str, info); 3436| 4.28M| if (pe.custom_error_message.size()) { ------------------ | Branch (3436:11): [True: 0, False: 4.28M] ------------------ 3437| 0| error_str.append(" "); 3438| 0| error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end()); 3439| 0| } 3440| 4.28M| return error_str; 3441| 4.28M| } _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz5pointEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm1ELm1EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2584| 7.21k| { 2585| | if constexpr (HashInfo.sized_hash) { 2586| | const auto* c = quote_memchr(it, end); 2587| | if (c) [[likely]] { 2588| | const auto n = size_t(static_cast>(c) - it); 2589| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2590| | return N; // error 2591| | } 2592| | 2593| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2594| | return HashInfo.table[h % bsize]; 2595| | } 2596| | else [[unlikely]] { 2597| | return N; 2598| | } 2599| | } 2600| 7.21k| else { 2601| 7.21k| if constexpr (N == 2) { 2602| | if constexpr (uindex > 0) { 2603| | if (size_t(end - it) <= uindex) [[unlikely]] { 2604| | return N; // error 2605| | } 2606| | } 2607| | // Avoids using a hash table 2608| 7.21k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2609| 7.21k| return size_t(bool(it[uindex] ^ first_key_char)); 2610| | } 2611| | else { 2612| | if constexpr (uindex > 0) { 2613| | if (size_t(end - it) <= uindex) [[unlikely]] { 2614| | return N; // error 2615| | } 2616| | } 2617| | return HashInfo.table[uint8_t(it[uindex])]; 2618| | } 2619| 7.21k| } 2620| 7.21k| } _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz8fuzz_apiEXtlNS_11hash_info_tIS2_Lm128EEELNS_9hash_typeE2EtlNSt3__15arrayIhLm128EEEtlA128_hLh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh11ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh6ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh9ELh13ELh13ELh13ELh13ELh13ELh12ELh13ELh13ELh13ELh13ELh0ELh13ELh13ELh13ELh13ELh13ELh13ELh5ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh4ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh1ELh13ELh10ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh2ELh3ELh13ELh13ELh13ELh13ELh13ELh13ELh8ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh7ELh13ELh13ELh13ELh13ELh13ELh13ELh13EEELm4ELm8ELm15149911783463666029ELm18446744073709551615ELb0ELm2EEELS5_2EE2opIRPKcSD_EEmOT_T0_: 2649| 33.7k| { 2650| 33.7k| if constexpr (HashInfo.front_hash_bytes == 2) { 2651| 33.7k| if (size_t(end - it) <= 2) [[unlikely]] { ------------------ | Branch (2651:17): [True: 9, False: 33.7k] ------------------ 2652| 9| return N; // error 2653| 9| } 2654| 33.7k| uint16_t h; 2655| | if consteval { 2656| | h = 0; 2657| | for (size_t i = 0; i < 2; ++i) { 2658| | h |= static_cast(static_cast(it[i])) << (8 * i); 2659| | } 2660| | } 2661| 33.7k| else { 2662| 33.7k| std::memcpy(&h, it, 2); 2663| | if constexpr (std::endian::native == std::endian::big) { 2664| | h = std::byteswap(h); 2665| | } 2666| 33.7k| } 2667| 33.7k| return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2668| | } 2669| | else if constexpr (HashInfo.front_hash_bytes == 4) { 2670| | if (size_t(end - it) <= 4) [[unlikely]] { 2671| | return N; 2672| | } 2673| | uint32_t h; 2674| | if consteval { 2675| | h = 0; 2676| | for (size_t i = 0; i < 4; ++i) { 2677| | h |= static_cast(static_cast(it[i])) << (8 * i); 2678| | } 2679| | } 2680| | else { 2681| | std::memcpy(&h, it, 4); 2682| | if constexpr (std::endian::native == std::endian::big) { 2683| | h = std::byteswap(h); 2684| | } 2685| | } 2686| | return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2687| | } 2688| | else if constexpr (HashInfo.front_hash_bytes == 8) { 2689| | if (size_t(end - it) <= 8) [[unlikely]] { 2690| | return N; 2691| | } 2692| | uint64_t h; 2693| | if consteval { 2694| | h = 0; 2695| | for (size_t i = 0; i < 8; ++i) { 2696| | h |= static_cast(static_cast(it[i])) << (8 * i); 2697| | } 2698| | } 2699| | else { 2700| | std::memcpy(&h, it, 8); 2701| | if constexpr (std::endian::native == std::endian::big) { 2702| | h = std::byteswap(h); 2703| | } 2704| | } 2705| | return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize]; 2706| | } 2707| | else { 2708| | static_assert(false_v, "invalid hash algorithm"); 2709| | } 2710| 33.7k| } _ZN3glz6bitmixEmm: 1570| 33.7k| { 1571| 33.7k| h *= seed; 1572| 33.7k| return h ^ std::rotr(h, 49); 1573| 33.7k| }; _ZN3glz11decode_hashILj10EN12jsonrpc_fuzz6nestedEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm5ELm5EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2584| 16.5k| { 2585| | if constexpr (HashInfo.sized_hash) { 2586| | const auto* c = quote_memchr(it, end); 2587| | if (c) [[likely]] { 2588| | const auto n = size_t(static_cast>(c) - it); 2589| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2590| | return N; // error 2591| | } 2592| | 2593| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2594| | return HashInfo.table[h % bsize]; 2595| | } 2596| | else [[unlikely]] { 2597| | return N; 2598| | } 2599| | } 2600| 16.5k| else { 2601| 16.5k| if constexpr (N == 2) { 2602| | if constexpr (uindex > 0) { 2603| | if (size_t(end - it) <= uindex) [[unlikely]] { 2604| | return N; // error 2605| | } 2606| | } 2607| | // Avoids using a hash table 2608| 16.5k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2609| 16.5k| return size_t(bool(it[uindex] ^ first_key_char)); 2610| | } 2611| | else { 2612| | if constexpr (uindex > 0) { 2613| | if (size_t(end - it) <= uindex) [[unlikely]] { 2614| | return N; // error 2615| | } 2616| | } 2617| | return HashInfo.table[uint8_t(it[uindex])]; 2618| | } 2619| 16.5k| } 2620| 16.5k| } _ZN3glz11decode_hashILj10ENS_3rpc18request_envelope_tEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh3ELh0ELh4ELh4ELh1ELh4ELh4ELh2ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4ELh4EEELm2ELm7EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2584| 305k| { 2585| | if constexpr (HashInfo.sized_hash) { 2586| | const auto* c = quote_memchr(it, end); 2587| | if (c) [[likely]] { 2588| | const auto n = size_t(static_cast>(c) - it); 2589| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2590| | return N; // error 2591| | } 2592| | 2593| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2594| | return HashInfo.table[h % bsize]; 2595| | } 2596| | else [[unlikely]] { 2597| | return N; 2598| | } 2599| | } 2600| 305k| else { 2601| | if constexpr (N == 2) { 2602| | if constexpr (uindex > 0) { 2603| | if (size_t(end - it) <= uindex) [[unlikely]] { 2604| | return N; // error 2605| | } 2606| | } 2607| | // Avoids using a hash table 2608| | constexpr auto first_key_char = reflect::keys[0][uindex]; 2609| | return size_t(bool(it[uindex] ^ first_key_char)); 2610| | } 2611| 305k| else { 2612| | if constexpr (uindex > 0) { 2613| | if (size_t(end - it) <= uindex) [[unlikely]] { 2614| | return N; // error 2615| | } 2616| | } 2617| 305k| return HashInfo.table[uint8_t(it[uindex])]; 2618| 305k| } 2619| 305k| } 2620| 305k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 79.7k| { 117| 79.7k| using D = std::remove_cvref_t; 118| 79.7k| if constexpr (tuple_detail::is_tuple) { 119| 79.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.7k| using T = typename D::template type_at; 121| 79.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| 79.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.7k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 79.7k| { 117| 79.7k| using D = std::remove_cvref_t; 118| 79.7k| if constexpr (tuple_detail::is_tuple) { 119| 79.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.7k| using T = typename D::template type_at; 121| 79.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| 79.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.7k| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 79.7k| { 117| 79.7k| using D = std::remove_cvref_t; 118| 79.7k| if constexpr (tuple_detail::is_tuple) { 119| 79.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.7k| using T = typename D::template type_at; 121| 79.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| 79.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.7k| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMN12jsonrpc_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EEEEEEDcOT0_: 116| 79.7k| { 117| 79.7k| using D = std::remove_cvref_t; 118| 79.7k| if constexpr (tuple_detail::is_tuple) { 119| 79.7k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.7k| using T = typename D::template type_at; 121| 79.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| 79.7k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.7k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 116| 5.76k| { 117| 5.76k| using D = std::remove_cvref_t; 118| 5.76k| if constexpr (tuple_detail::is_tuple) { 119| 5.76k| static_assert(I < D::N, "glz::get index is out of range"); 120| 5.76k| 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| 5.76k| else { 128| 5.76k| return static_cast(static_cast&>(tup).value); 129| 5.76k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 5.76k| } _ZN3glz3tieIJddEEENS_5tupleIJDpRT_EEES4_: 325| 87.2k| { 326| 87.2k| return {{{ts}...}}; 327| 87.2k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 116| 1.22k| { 117| 1.22k| using D = std::remove_cvref_t; 118| 1.22k| if constexpr (tuple_detail::is_tuple) { 119| 1.22k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.22k| 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.22k| else { 128| 1.22k| return static_cast(static_cast&>(tup).value); 129| 1.22k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.22k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 116| 80.2k| { 117| 80.2k| using D = std::remove_cvref_t; 118| 80.2k| if constexpr (tuple_detail::is_tuple) { 119| 80.2k| static_assert(I < D::N, "glz::get index is out of range"); 120| 80.2k| using T = typename D::template type_at; 121| 80.2k| 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| 80.2k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 80.2k| 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| 80.2k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 116| 80.2k| { 117| 80.2k| using D = std::remove_cvref_t; 118| 80.2k| if constexpr (tuple_detail::is_tuple) { 119| 80.2k| static_assert(I < D::N, "glz::get index is out of range"); 120| 80.2k| using T = typename D::template type_at; 121| 80.2k| 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| 80.2k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 80.2k| 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| 80.2k| } _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| 17.3k| { 117| 17.3k| using D = std::remove_cvref_t; 118| 17.3k| if constexpr (tuple_detail::is_tuple) { 119| 17.3k| static_assert(I < D::N, "glz::get index is out of range"); 120| 17.3k| 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| 17.3k| else { 128| 17.3k| return static_cast(static_cast&>(tup).value); 129| 17.3k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 17.3k| } _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| 112k| { 326| 112k| return {{{ts}...}}; 327| 112k| } _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| 50| { 117| 50| using D = std::remove_cvref_t; 118| 50| if constexpr (tuple_detail::is_tuple) { 119| 50| static_assert(I < D::N, "glz::get index is out of range"); 120| 50| 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| 50| else { 128| 50| return static_cast(static_cast&>(tup).value); 129| 50| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 50| } _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| 849| { 117| 849| using D = std::remove_cvref_t; 118| 849| if constexpr (tuple_detail::is_tuple) { 119| 849| static_assert(I < D::N, "glz::get index is out of range"); 120| 849| 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| 849| else { 128| 849| return static_cast(static_cast&>(tup).value); 129| 849| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 849| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 15.5k| { 117| 15.5k| using D = std::remove_cvref_t; 118| 15.5k| if constexpr (tuple_detail::is_tuple) { 119| 15.5k| static_assert(I < D::N, "glz::get index is out of range"); 120| 15.5k| 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| 15.5k| else { 128| 15.5k| return static_cast(static_cast&>(tup).value); 129| 15.5k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 15.5k| } _ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_5tupleIJDpRT_EEESB_: 325| 96.1k| { 326| 96.1k| return {{{ts}...}}; 327| 96.1k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 721| { 117| 721| using D = std::remove_cvref_t; 118| 721| if constexpr (tuple_detail::is_tuple) { 119| 721| static_assert(I < D::N, "glz::get index is out of range"); 120| 721| 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| 721| else { 128| 721| return static_cast(static_cast&>(tup).value); 129| 721| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 721| } _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| 675| { 117| 675| using D = std::remove_cvref_t; 118| 675| if constexpr (tuple_detail::is_tuple) { 119| 675| static_assert(I < D::N, "glz::get index is out of range"); 120| 675| 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| 675| else { 128| 675| return static_cast(static_cast&>(tup).value); 129| 675| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 675| } _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| 8.16k| { 117| 8.16k| using D = std::remove_cvref_t; 118| 8.16k| if constexpr (tuple_detail::is_tuple) { 119| 8.16k| static_assert(I < D::N, "glz::get index is out of range"); 120| 8.16k| 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| 8.16k| else { 128| 8.16k| return static_cast(static_cast&>(tup).value); 129| 8.16k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 8.16k| } _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.18k| { 117| 1.18k| using D = std::remove_cvref_t; 118| 1.18k| if constexpr (tuple_detail::is_tuple) { 119| 1.18k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.18k| 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.18k| else { 128| 1.18k| return static_cast(static_cast&>(tup).value); 129| 1.18k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.18k| } _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.38k| { 117| 1.38k| using D = std::remove_cvref_t; 118| 1.38k| if constexpr (tuple_detail::is_tuple) { 119| 1.38k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.38k| 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.38k| else { 128| 1.38k| return static_cast(static_cast&>(tup).value); 129| 1.38k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.38k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableENS_5tupleIJRdEEEEEDcOT0_: 116| 329| { 117| 329| using D = std::remove_cvref_t; 118| 329| if constexpr (tuple_detail::is_tuple) { 119| 329| static_assert(I < D::N, "glz::get index is out of range"); 120| 329| 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| 329| else { 128| 329| return static_cast(static_cast&>(tup).value); 129| 329| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 329| } _ZN3glz3tieIJdEEENS_5tupleIJDpRT_EEES4_: 325| 329| { 326| 329| return {{{ts}...}}; 327| 329| } _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.35k| { 117| 1.35k| using D = std::remove_cvref_t; 118| 1.35k| if constexpr (tuple_detail::is_tuple) { 119| 1.35k| static_assert(I < D::N, "glz::get index is out of range"); 120| 1.35k| 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.35k| else { 128| 1.35k| return static_cast(static_cast&>(tup).value); 129| 1.35k| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 1.35k| } _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| 306| { 117| 306| using D = std::remove_cvref_t; 118| 306| if constexpr (tuple_detail::is_tuple) { 119| 306| static_assert(I < D::N, "glz::get index is out of range"); 120| 306| 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| 306| else { 128| 306| return static_cast(static_cast&>(tup).value); 129| 306| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 306| } _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| 394| { 117| 394| using D = std::remove_cvref_t; 118| 394| if constexpr (tuple_detail::is_tuple) { 119| 394| static_assert(I < D::N, "glz::get index is out of range"); 120| 394| 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| 394| else { 128| 394| return static_cast(static_cast&>(tup).value); 129| 394| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 394| } _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| 345| { 117| 345| using D = std::remove_cvref_t; 118| 345| if constexpr (tuple_detail::is_tuple) { 119| 345| static_assert(I < D::N, "glz::get index is out of range"); 120| 345| 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| 345| else { 128| 345| return static_cast(static_cast&>(tup).value); 129| 345| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 345| } _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| 292| { 117| 292| using D = std::remove_cvref_t; 118| 292| if constexpr (tuple_detail::is_tuple) { 119| 292| static_assert(I < D::N, "glz::get index is out of range"); 120| 292| 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| 292| else { 128| 292| return static_cast(static_cast&>(tup).value); 129| 292| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 292| } _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| 189| { 117| 189| using D = std::remove_cvref_t; 118| 189| if constexpr (tuple_detail::is_tuple) { 119| 189| static_assert(I < D::N, "glz::get index is out of range"); 120| 189| 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| 189| else { 128| 189| return static_cast(static_cast&>(tup).value); 129| 189| } 130| | } 131| | else { 132| | return (static_cast(tup)[I]); 133| | } 134| 189| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 116| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _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| 79.8k| { 117| 79.8k| using D = std::remove_cvref_t; 118| 79.8k| if constexpr (tuple_detail::is_tuple) { 119| 79.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 79.8k| using T = typename D::template type_at; 121| 79.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| 79.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 79.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| 79.8k| } _ZN3glz3getILm0ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 72.8k| { 117| 72.8k| using D = std::remove_cvref_t; 118| 72.8k| if constexpr (tuple_detail::is_tuple) { 119| 72.8k| static_assert(I < D::N, "glz::get index is out of range"); 120| 72.8k| using T = typename D::template type_at; 121| 72.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| 72.8k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 72.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| 72.8k| } _ZN3glz3getILm1ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 64.2k| { 117| 64.2k| using D = std::remove_cvref_t; 118| 64.2k| if constexpr (tuple_detail::is_tuple) { 119| 64.2k| static_assert(I < D::N, "glz::get index is out of range"); 120| 64.2k| using T = typename D::template type_at; 121| 64.2k| 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.2k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 64.2k| 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.2k| } _ZN3glz3getILm2ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 46.0k| { 117| 46.0k| using D = std::remove_cvref_t; 118| 46.0k| if constexpr (tuple_detail::is_tuple) { 119| 46.0k| static_assert(I < D::N, "glz::get index is out of range"); 120| 46.0k| using T = typename D::template type_at; 121| 46.0k| 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| 46.0k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 46.0k| 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| 46.0k| } _ZN3glz3getILm3ETkNS_12tuple_detail9indexableERKNS_5tupleIJMNS_3rpc18request_envelope_tENSt3__18optionalINS5_17basic_string_viewIcNS5_11char_traitsIcEEEEEESC_MS4_NS_14basic_raw_jsonISA_EEMS4_NS5_7variantIJDnSA_lEEEEEEEEDcOT0_: 116| 83.6k| { 117| 83.6k| using D = std::remove_cvref_t; 118| 83.6k| if constexpr (tuple_detail::is_tuple) { 119| 83.6k| static_assert(I < D::N, "glz::get index is out of range"); 120| 83.6k| using T = typename D::template type_at; 121| 83.6k| 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| 83.6k| using leaf = tuple_detail::match_const_t, tuple_detail::elem>; 125| 83.6k| 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| 83.6k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOSB_: 101| 45.1k| { 102| 45.1k| std::string buffer{}; 103| 45.1k| context ctx{}; 104| 45.1k| const auto res = write(std::forward(value), buffer, ctx); 105| 45.1k| if (res) [[unlikely]] { ------------------ | Branch (105:11): [True: 0, False: 45.1k] ------------------ 106| 0| return glz::unexpected(res); 107| 0| } 108| 45.1k| return {buffer}; 109| 45.1k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_: 18| 45.1k| { 19| 45.1k| using traits = buffer_traits>; 20| 45.1k| call_scope scope{ctx}; 21| | 22| 45.1k| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 45.1k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 45.1k, False: 0] ------------------ 25| 45.1k| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 45.1k| } 27| 45.1k| } 28| 45.1k| size_t ix = 0; // overwrite index 29| 45.1k| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 45.1k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 45.1k] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 45.1k| traits::finalize(buffer, ix); 43| 45.1k| return {ix, error_code::none, ctx.custom_error_message}; 44| 45.1k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOSA_: 101| 44.7k| { 102| 44.7k| std::string buffer{}; 103| 44.7k| context ctx{}; 104| 44.7k| const auto res = write(std::forward(value), buffer, ctx); 105| 44.7k| if (res) [[unlikely]] { ------------------ | Branch (105:11): [True: 0, False: 44.7k] ------------------ 106| 0| return glz::unexpected(res); 107| 0| } 108| 44.7k| return {buffer}; 109| 44.7k| } _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.7k| { 19| 44.7k| using traits = buffer_traits>; 20| 44.7k| call_scope scope{ctx}; 21| | 22| 44.7k| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 44.7k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 44.7k, False: 0] ------------------ 25| 44.7k| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 44.7k| } 27| 44.7k| } 28| 44.7k| size_t ix = 0; // overwrite index 29| 44.7k| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 44.7k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 44.7k] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 44.7k| traits::finalize(buffer, ix); 43| 44.7k| return {ix, error_code::none, ctx.custom_error_message}; 44| 44.7k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 93| 438| { 94| 438| context ctx{}; 95| 438| return write(std::forward(value), buffer, ctx); 96| 438| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 438| { 19| 438| using traits = buffer_traits>; 20| 438| call_scope scope{ctx}; 21| | 22| 438| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 438| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 438, False: 0] ------------------ 25| 438| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 438| } 27| 438| } 28| 438| size_t ix = 0; // overwrite index 29| 438| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 438| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 438] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 438| traits::finalize(buffer, ix); 43| 438| return {ix, error_code::none, ctx.custom_error_message}; 44| 438| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_: 93| 295| { 94| 295| context ctx{}; 95| 295| return write(std::forward(value), buffer, ctx); 96| 295| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 295| { 19| 295| using traits = buffer_traits>; 20| 295| call_scope scope{ctx}; 21| | 22| 295| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 295| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 295, False: 0] ------------------ 25| 295| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 295| } 27| 295| } 28| 295| size_t ix = 0; // overwrite index 29| 295| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 295| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 295] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 295| traits::finalize(buffer, ix); 43| 295| return {ix, error_code::none, ctx.custom_error_message}; 44| 295| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_: 93| 129| { 94| 129| context ctx{}; 95| 129| return write(std::forward(value), buffer, ctx); 96| 129| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_: 18| 129| { 19| 129| using traits = buffer_traits>; 20| 129| call_scope scope{ctx}; 21| | 22| 129| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 129| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 129, False: 0] ------------------ 25| 129| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 129| } 27| 129| } 28| 129| size_t ix = 0; // overwrite index 29| 129| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 129| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 129] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 129| traits::finalize(buffer, ix); 43| 129| return {ix, error_code::none, ctx.custom_error_message}; 44| 129| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 93| 60| { 94| 60| context ctx{}; 95| 60| return write(std::forward(value), buffer, ctx); 96| 60| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 60| { 19| 60| using traits = buffer_traits>; 20| 60| call_scope scope{ctx}; 21| | 22| 60| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 60| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 60, False: 0] ------------------ 25| 60| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 60| } 27| 60| } 28| 60| size_t ix = 0; // overwrite index 29| 60| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 60| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 60] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 60| traits::finalize(buffer, ix); 43| 60| return {ix, error_code::none, ctx.custom_error_message}; 44| 60| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 93| 748| { 94| 748| context ctx{}; 95| 748| return write(std::forward(value), buffer, ctx); 96| 748| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 748| { 19| 748| using traits = buffer_traits>; 20| 748| call_scope scope{ctx}; 21| | 22| 748| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 748| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 748, False: 0] ------------------ 25| 748| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 748| } 27| 748| } 28| 748| size_t ix = 0; // overwrite index 29| 748| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 748| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 748] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 748| traits::finalize(buffer, ix); 43| 748| return {ix, error_code::none, ctx.custom_error_message}; 44| 748| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 93| 1.88k| { 94| 1.88k| context ctx{}; 95| 1.88k| return write(std::forward(value), buffer, ctx); 96| 1.88k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 1.88k| { 19| 1.88k| using traits = buffer_traits>; 20| 1.88k| call_scope scope{ctx}; 21| | 22| 1.88k| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 1.88k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 1.88k, False: 0] ------------------ 25| 1.88k| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 1.88k| } 27| 1.88k| } 28| 1.88k| size_t ix = 0; // overwrite index 29| 1.88k| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 1.88k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 1.88k] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 1.88k| traits::finalize(buffer, ix); 43| 1.88k| return {ix, error_code::none, ctx.custom_error_message}; 44| 1.88k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 93| 259| { 94| 259| context ctx{}; 95| 259| return write(std::forward(value), buffer, ctx); 96| 259| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 259| { 19| 259| using traits = buffer_traits>; 20| 259| call_scope scope{ctx}; 21| | 22| 259| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 259| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 259, False: 0] ------------------ 25| 259| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 259| } 27| 259| } 28| 259| size_t ix = 0; // overwrite index 29| 259| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 259| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 259] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 259| traits::finalize(buffer, ix); 43| 259| return {ix, error_code::none, ctx.custom_error_message}; 44| 259| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 93| 41| { 94| 41| context ctx{}; 95| 41| return write(std::forward(value), buffer, ctx); 96| 41| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 41| { 19| 41| using traits = buffer_traits>; 20| 41| call_scope scope{ctx}; 21| | 22| 41| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 41| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 41, False: 0] ------------------ 25| 41| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 41| } 27| 41| } 28| 41| size_t ix = 0; // overwrite index 29| 41| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 41| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 41] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 41| traits::finalize(buffer, ix); 43| 41| return {ix, error_code::none, ctx.custom_error_message}; 44| 41| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_: 93| 86| { 94| 86| context ctx{}; 95| 86| return write(std::forward(value), buffer, ctx); 96| 86| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_: 18| 86| { 19| 86| using traits = buffer_traits>; 20| 86| call_scope scope{ctx}; 21| | 22| 86| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 86| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 86, False: 0] ------------------ 25| 86| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 86| } 27| 86| } 28| 86| size_t ix = 0; // overwrite index 29| 86| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 86| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 86] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 86| traits::finalize(buffer, ix); 43| 86| return {ix, error_code::none, ctx.custom_error_message}; 44| 86| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSI_RT1_: 93| 40| { 94| 40| context ctx{}; 95| 40| return write(std::forward(value), buffer, ctx); 96| 40| } _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| 40| { 19| 40| using traits = buffer_traits>; 20| 40| call_scope scope{ctx}; 21| | 22| 40| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 40| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 40, False: 0] ------------------ 25| 40| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 40| } 27| 40| } 28| 40| size_t ix = 0; // overwrite index 29| 40| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 40| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 40] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 40| traits::finalize(buffer, ix); 43| 40| return {ix, error_code::none, ctx.custom_error_message}; 44| 40| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 93| 62| { 94| 62| context ctx{}; 95| 62| return write(std::forward(value), buffer, ctx); 96| 62| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 62| { 19| 62| using traits = buffer_traits>; 20| 62| call_scope scope{ctx}; 21| | 22| 62| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 62| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 62, False: 0] ------------------ 25| 62| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 62| } 27| 62| } 28| 62| size_t ix = 0; // overwrite index 29| 62| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 62| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 62] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 62| traits::finalize(buffer, ix); 43| 62| return {ix, error_code::none, ctx.custom_error_message}; 44| 62| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_: 93| 54| { 94| 54| context ctx{}; 95| 54| return write(std::forward(value), buffer, ctx); 96| 54| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_: 18| 54| { 19| 54| using traits = buffer_traits>; 20| 54| call_scope scope{ctx}; 21| | 22| 54| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 54| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 54, False: 0] ------------------ 25| 54| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 54| } 27| 54| } 28| 54| size_t ix = 0; // overwrite index 29| 54| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 54| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 54] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 54| traits::finalize(buffer, ix); 43| 54| return {ix, error_code::none, ctx.custom_error_message}; 44| 54| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedIS8_NS_9error_ctxEEEOS9_: 101| 4.26M| { 102| 4.26M| std::string buffer{}; 103| 4.26M| context ctx{}; 104| 4.26M| const auto res = write(std::forward(value), buffer, ctx); 105| 4.26M| if (res) [[unlikely]] { ------------------ | Branch (105:11): [True: 0, False: 4.26M] ------------------ 106| 0| return glz::unexpected(res); 107| 0| } 108| 4.26M| return {buffer}; 109| 4.26M| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 4.26M| { 19| 4.26M| using traits = buffer_traits>; 20| 4.26M| call_scope scope{ctx}; 21| | 22| 4.26M| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 4.26M| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 4.26M, False: 0] ------------------ 25| 4.26M| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 4.26M| } 27| 4.26M| } 28| 4.26M| size_t ix = 0; // overwrite index 29| 4.26M| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 4.26M| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 4.26M] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 4.26M| traits::finalize(buffer, ix); 43| 4.26M| return {ix, error_code::none, ctx.custom_error_message}; 44| 4.26M| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOS9_: 101| 70| { 102| 70| std::string buffer{}; 103| 70| context ctx{}; 104| 70| const auto res = write(std::forward(value), buffer, ctx); 105| 70| if (res) [[unlikely]] { ------------------ | Branch (105:11): [True: 0, False: 70] ------------------ 106| 0| return glz::unexpected(res); 107| 0| } 108| 70| return {buffer}; 109| 70| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEETkNS_13output_bufferENS2_12basic_stringIcS5_NS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_: 18| 70| { 19| 70| using traits = buffer_traits>; 20| 70| call_scope scope{ctx}; 21| | 22| 70| if constexpr (traits::is_resizable) { 23| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 24| 70| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (24:14): [True: 70, False: 0] ------------------ 25| 70| resize_unfilled(buffer, 2 * write_padding_bytes); 26| 70| } 27| 70| } 28| 70| size_t ix = 0; // overwrite index 29| 70| to>::template op(std::forward(value), ctx, buffer, ix); 30| | 31| 70| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (31:11): [True: 0, False: 70] ------------------ 32| | // Truncate on the way out too: the padding above is grown without being filled, so a 33| | // buffer left at its padded length would hand the caller indeterminate bytes. Not 34| | // `finalize`, which for a streaming buffer means flushing -- a failed write must not 35| | // push the partial document downstream on its way out. 36| 0| if constexpr (traits::is_resizable && not traits::is_output_streaming) { 37| 0| buffer.resize(ix); 38| 0| } 39| 0| return {ix, ctx.error, ctx.custom_error_message}; 40| 0| } 41| | 42| 70| traits::finalize(buffer, ix); 43| 70| return {ix, error_code::none, ctx.custom_error_message}; 44| 70| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 33.2k| { 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| 33.2k| 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| 33.2k| else if constexpr (is_any_of) { 347| 33.2k| 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| 33.2k| else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| 33.2k| const auto end = glz::to_chars_40kb(start, value); 356| 33.2k| ix += size_t(end - start); 357| 33.2k| } 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| 33.2k| } _ZN3glz11write_chars2opITnDaXtlNS_9opts_sizeEtlNS_4optsELj10ELb1ELb0ELb1ELb1EEEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_5num_tERKmTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 4.56M| { 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.56M| if constexpr (resizable && not check_write_unchecked(Opts)) { 214| 4.56M| if (const auto k = ix + 64; k > b.size()) { ------------------ | Branch (214:41): [True: 0, False: 4.56M] ------------------ 215| 0| grow_buffer(b, k); 216| 0| } 217| 4.56M| } 218| | 219| 4.56M| 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.56M| else if constexpr (is_any_of) { 347| 4.56M| const auto start = reinterpret_cast(&b[ix]); 348| 4.56M| if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| 4.56M| const auto end = glz::to_chars(start, value); 351| 4.56M| 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.56M| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 894| { 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| 894| 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| 894| else if constexpr (is_any_of) { 347| 894| 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| 894| else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| 894| const auto end = glz::to_chars_40kb(start, value); 356| 894| ix += size_t(end - start); 357| 894| } 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| 894| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 2.77k| { 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.77k| using V = std::decay_t; 220| | 221| 2.77k| if constexpr (std::floating_point) { 222| 2.77k| using opts_type = std::decay_t; 223| 2.77k| 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.77k| else if constexpr (is_any_of) { 319| 2.77k| const auto start = reinterpret_cast(&b[ix]); 320| 2.77k| const auto end = glz::to_chars(start, value); 321| 2.77k| 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.77k| } _ZN3glz9sweethash7sweet32ITkNS0_16contiguous_rangeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEjRKT_j: 270| 720| { 271| 720| return sweet32(static_cast(s.data()), s.size(), seed); 272| 720| } _ZN3glz9sweethash7sweet32EPKvmj: 154| 720| { 155| 720| const uint8_t* p = static_cast(data); 156| | 157| | // For inputs <= 8 bytes, use simple hash (tail handler requires len >= 9) 158| 720| if (len <= 8) { ------------------ | Branch (158:11): [True: 720, False: 0] ------------------ 159| 720| uint64_t v = 0; 160| 720| switch (len) { 161| 120| case 8: ------------------ | Branch (161:10): [True: 120, False: 600] ------------------ 162| 120| std::memcpy(&v, p, 8); 163| 120| break; 164| 120| case 7: ------------------ | Branch (164:10): [True: 120, False: 600] ------------------ 165| 120| std::memcpy(&v, p, 7); 166| 120| break; 167| 60| case 6: ------------------ | Branch (167:10): [True: 60, False: 660] ------------------ 168| 60| std::memcpy(&v, p, 6); 169| 60| break; 170| 360| case 5: ------------------ | Branch (170:10): [True: 360, False: 360] ------------------ 171| 360| std::memcpy(&v, p, 5); 172| 360| break; 173| 60| case 4: ------------------ | Branch (173:10): [True: 60, False: 660] ------------------ 174| 60| std::memcpy(&v, p, 4); 175| 60| break; 176| 0| case 3: ------------------ | Branch (176:10): [True: 0, False: 720] ------------------ 177| 0| std::memcpy(&v, p, 3); 178| 0| break; 179| 0| case 2: ------------------ | Branch (179:10): [True: 0, False: 720] ------------------ 180| 0| std::memcpy(&v, p, 2); 181| 0| break; 182| 0| case 1: ------------------ | Branch (182:10): [True: 0, False: 720] ------------------ 183| 0| v = p[0]; 184| 0| break; 185| 0| default: ------------------ | Branch (185:10): [True: 0, False: 720] ------------------ 186| 0| break; 187| 720| } 188| 720| v = v ^ seed ^ (len + 1); 189| 720| return static_cast(v) ^ static_cast(v >> 32); 190| 720| } 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| 720| } _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2Ev: 379| 3.86M| generic_json() = default; _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEC2EOS3_: 382| 4.09M| generic_json(generic_json&& other) noexcept : data(std::move(other.data)) {} _ZN3glz12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEED2Ev: 131| 7.96M| ~generic_json() = default; _ZN3glz11get_as_jsonINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEETnNS_14string_literalEXtlNS8_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERS6_EENS1_8expectedIT_NS_9error_ctxEEEOT2_: 208| 95.4k| { 209| 95.4k| const auto str = glz::get_view_json(buffer); 210| 95.4k| if (str) { ------------------ | Branch (210:11): [True: 20.6k, False: 74.8k] ------------------ 211| 20.6k| T value{}; 212| 20.6k| context ctx{}; 213| 20.6k| if (const auto ec = glz::read(value, *str, ctx); ec) { ------------------ | Branch (213:65): [True: 14.5k, False: 6.08k] ------------------ 214| 14.5k| return unexpected(ec); 215| 14.5k| } 216| 6.08k| return value; 217| 20.6k| } 218| 74.8k| return unexpected(str.error()); 219| 95.4k| } _ZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_: 23| 95.4k| { 24| 95.4k| static constexpr auto S = chars; 25| 95.4k| static constexpr auto tokens = split_json_ptr(); 26| 95.4k| static constexpr auto N = tokens.size(); 27| | 28| 95.4k| context ctx{}; 29| 95.4k| auto p = read_iterators(buffer); 30| | 31| 95.4k| auto it = p.first; 32| 95.4k| auto end = p.second; 33| | 34| | // Don't automatically const qualify the buffer so we can write to the view, 35| | // which allows us to write to a JSON Pointer location 36| 95.4k| using span_t = 37| 95.4k| std::span>, const char, char>>; 38| 95.4k| using result_t = expected; 39| | 40| 95.4k| auto start = it; 41| | 42| 95.4k| if (buffer.size() == 0) [[unlikely]] { ------------------ | Branch (42:11): [True: 0, False: 95.4k] ------------------ 43| 0| ctx.error = error_code::no_read_input; 44| 0| } 45| | 46| 95.4k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (46:11): [True: 0, False: 95.4k] ------------------ 47| 0| return result_t{unexpected(error_ctx{0, ctx.error})}; 48| 0| } 49| | 50| | if constexpr (N == 0) { 51| | return result_t{span_t{it, end}}; 52| | } 53| 95.4k| else { 54| 95.4k| using namespace glz::detail; 55| | 56| 95.4k| skip_ws(ctx, it, end); 57| | 58| 95.4k| result_t ret; 59| | 60| 95.4k| for_each([&]() { 61| 95.4k| if (bool(ctx.error)) [[unlikely]] { 62| 95.4k| return; 63| 95.4k| } 64| | 65| 95.4k| static constexpr auto key = tokens[I]; 66| 95.4k| if constexpr (maybe_numeric_key(key)) { 67| 95.4k| switch (*it) { 68| 95.4k| case '{': { 69| 95.4k| ++it; 70| 95.4k| while (true) { 71| 95.4k| if (skip_ws(ctx, it, end)) { 72| 95.4k| return; 73| 95.4k| } 74| 95.4k| if (match<'"'>(ctx, it)) { 75| 95.4k| return; 76| 95.4k| } 77| | 78| 95.4k| auto* start = it; 79| 95.4k| skip_string_view(ctx, it, end); 80| 95.4k| if (bool(ctx.error)) [[unlikely]] 81| 95.4k| return; 82| 95.4k| const sv k = {start, size_t(it - start)}; 83| 95.4k| ++it; 84| | 85| 95.4k| if (key.size() == k.size() && comparitor(k.data())) { 86| 95.4k| if (skip_ws(ctx, it, end)) { 87| 95.4k| return; 88| 95.4k| } 89| 95.4k| if (match_invalid_end<':', Opts>(ctx, it, end)) { 90| 95.4k| return; 91| 95.4k| } 92| 95.4k| if (skip_ws(ctx, it, end)) { 93| 95.4k| return; 94| 95.4k| } 95| | 96| 95.4k| if constexpr (I == (N - 1)) { 97| 95.4k| ret = parse_value(ctx, it, end); 98| 95.4k| } 99| 95.4k| return; 100| 95.4k| } 101| 95.4k| else { 102| 95.4k| skip_value::op(ctx, it, end); 103| 95.4k| if (bool(ctx.error)) [[unlikely]] { 104| 95.4k| return; 105| 95.4k| } 106| 95.4k| if (it >= end || *it != ',') { 107| 95.4k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 108| 95.4k| return; 109| 95.4k| } 110| 95.4k| ++it; 111| 95.4k| } 112| 95.4k| } 113| 95.4k| } 114| 95.4k| case '[': { 115| 95.4k| ++it; 116| | // Could optimize by counting commas 117| 95.4k| static constexpr auto n = detail::parse_json_ptr_array_index(key); 118| 95.4k| if constexpr (n) { 119| 95.4k| for_each([&]() { 120| 95.4k| skip_value::op(ctx, it, end); 121| 95.4k| if (bool(ctx.error)) [[unlikely]] { 122| 95.4k| return; 123| 95.4k| } 124| 95.4k| if (it >= end || *it != ',') { 125| 95.4k| ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found; 126| 95.4k| return; 127| 95.4k| } 128| 95.4k| ++it; 129| 95.4k| }); 130| | 131| 95.4k| if (skip_ws(ctx, it, end)) { 132| 95.4k| return; 133| 95.4k| } 134| | 135| 95.4k| if constexpr (I == (N - 1)) { 136| 95.4k| ret = parse_value(ctx, it, end); 137| 95.4k| } 138| 95.4k| return; 139| 95.4k| } 140| 95.4k| else { 141| 95.4k| ctx.error = error_code::array_element_not_found; 142| 95.4k| return; 143| 95.4k| } 144| 95.4k| } 145| 95.4k| } 146| 95.4k| } 147| 95.4k| else { 148| 95.4k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { 149| 95.4k| return; 150| 95.4k| } 151| | 152| 95.4k| while (it < end) { 153| 95.4k| if (skip_ws(ctx, it, end)) { 154| 95.4k| return; 155| 95.4k| } 156| 95.4k| if (match<'"'>(ctx, it)) { 157| 95.4k| return; 158| 95.4k| } 159| | 160| 95.4k| auto* start = it; 161| 95.4k| skip_string_view(ctx, it, end); 162| 95.4k| if (bool(ctx.error)) [[unlikely]] 163| 95.4k| return; 164| 95.4k| const sv k = {start, size_t(it - start)}; 165| 95.4k| ++it; 166| | 167| 95.4k| if (key.size() == k.size() && comparitor(k.data())) { 168| 95.4k| if (skip_ws(ctx, it, end)) { 169| 95.4k| return; 170| 95.4k| } 171| 95.4k| if (match_invalid_end<':', Opts>(ctx, it, end)) { 172| 95.4k| return; 173| 95.4k| } 174| 95.4k| if (skip_ws(ctx, it, end)) { 175| 95.4k| return; 176| 95.4k| } 177| | 178| 95.4k| if constexpr (I == (N - 1)) { 179| 95.4k| ret = parse_value(ctx, it, end); 180| 95.4k| } 181| 95.4k| return; 182| 95.4k| } 183| 95.4k| else { 184| 95.4k| skip_value::op(ctx, it, end); 185| 95.4k| if (bool(ctx.error)) [[unlikely]] { 186| 95.4k| return; 187| 95.4k| } 188| 95.4k| if (it >= end || *it != ',') { 189| 95.4k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 190| 95.4k| return; 191| 95.4k| } 192| 95.4k| ++it; 193| 95.4k| } 194| 95.4k| } 195| 95.4k| } 196| 95.4k| }); 197| | 198| 95.4k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (198:14): [True: 74.8k, False: 20.6k] ------------------ 199| 74.8k| return result_t{unexpected(error_ctx{size_t(it - start), ctx.error})}; 200| 74.8k| } 201| | 202| 20.6k| return ret; 203| 95.4k| } 204| 95.4k| } _ZZN3glz13get_view_jsonITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDav: 60| 95.4k| for_each([&]() { 61| 95.4k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (61:17): [True: 0, False: 95.4k] ------------------ 62| 0| return; 63| 0| } 64| | 65| 95.4k| static constexpr auto key = tokens[I]; 66| | if constexpr (maybe_numeric_key(key)) { 67| | switch (*it) { 68| | case '{': { 69| | ++it; 70| | while (true) { 71| | if (skip_ws(ctx, it, end)) { 72| | return; 73| | } 74| | if (match<'"'>(ctx, it)) { 75| | return; 76| | } 77| | 78| | auto* start = it; 79| | skip_string_view(ctx, it, end); 80| | if (bool(ctx.error)) [[unlikely]] 81| | return; 82| | const sv k = {start, size_t(it - start)}; 83| | ++it; 84| | 85| | if (key.size() == k.size() && comparitor(k.data())) { 86| | if (skip_ws(ctx, it, end)) { 87| | return; 88| | } 89| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 90| | return; 91| | } 92| | if (skip_ws(ctx, it, end)) { 93| | return; 94| | } 95| | 96| | if constexpr (I == (N - 1)) { 97| | ret = parse_value(ctx, it, end); 98| | } 99| | return; 100| | } 101| | else { 102| | skip_value::op(ctx, it, end); 103| | if (bool(ctx.error)) [[unlikely]] { 104| | return; 105| | } 106| | if (it >= end || *it != ',') { 107| | ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; 108| | return; 109| | } 110| | ++it; 111| | } 112| | } 113| | } 114| | case '[': { 115| | ++it; 116| | // Could optimize by counting commas 117| | static constexpr auto n = detail::parse_json_ptr_array_index(key); 118| | if constexpr (n) { 119| | for_each([&]() { 120| | skip_value::op(ctx, it, end); 121| | if (bool(ctx.error)) [[unlikely]] { 122| | return; 123| | } 124| | if (it >= end || *it != ',') { 125| | ctx.error = it >= end ? error_code::unexpected_end : error_code::array_element_not_found; 126| | return; 127| | } 128| | ++it; 129| | }); 130| | 131| | if (skip_ws(ctx, it, end)) { 132| | return; 133| | } 134| | 135| | if constexpr (I == (N - 1)) { 136| | ret = parse_value(ctx, it, end); 137| | } 138| | return; 139| | } 140| | else { 141| | ctx.error = error_code::array_element_not_found; 142| | return; 143| | } 144| | } 145| | } 146| | } 147| 95.4k| else { 148| 95.4k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (148:20): [True: 67.1k, False: 28.3k] ------------------ 149| 67.1k| return; 150| 67.1k| } 151| | 152| 52.9k| while (it < end) { ------------------ | Branch (152:23): [True: 52.9k, False: 0] ------------------ 153| 52.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (153:23): [True: 0, False: 52.9k] ------------------ 154| 0| return; 155| 0| } 156| 52.9k| if (match<'"'>(ctx, it)) { ------------------ | Branch (156:23): [True: 0, False: 52.9k] ------------------ 157| 0| return; 158| 0| } 159| | 160| 52.9k| auto* start = it; 161| 52.9k| skip_string_view(ctx, it, end); 162| 52.9k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (162:23): [True: 0, False: 52.9k] ------------------ 163| 0| return; 164| 52.9k| const sv k = {start, size_t(it - start)}; 165| 52.9k| ++it; 166| | 167| 52.9k| if (key.size() == k.size() && comparitor(k.data())) { ------------------ | Branch (167:23): [True: 25.1k, False: 27.8k] | Branch (167:49): [True: 20.6k, False: 4.44k] ------------------ 168| 20.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (168:26): [True: 0, False: 20.6k] ------------------ 169| 0| return; 170| 0| } 171| 20.6k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (171:26): [True: 0, False: 20.6k] ------------------ 172| 0| return; 173| 0| } 174| 20.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (174:26): [True: 0, False: 20.6k] ------------------ 175| 0| return; 176| 0| } 177| | 178| 20.6k| if constexpr (I == (N - 1)) { 179| 20.6k| ret = parse_value(ctx, it, end); 180| 20.6k| } 181| 20.6k| return; 182| 20.6k| } 183| 32.2k| else { 184| 32.2k| skip_value::op(ctx, it, end); 185| 32.2k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (185:26): [True: 0, False: 32.2k] ------------------ 186| 0| return; 187| 0| } 188| 32.2k| if (it >= end || *it != ',') { ------------------ | Branch (188:26): [True: 0, False: 32.2k] | Branch (188:39): [True: 7.68k, False: 24.5k] ------------------ 189| 7.68k| ctx.error = it >= end ? error_code::unexpected_end : error_code::key_not_found; ------------------ | Branch (189:37): [True: 0, False: 7.68k] ------------------ 190| 7.68k| return; 191| 7.68k| } 192| 24.5k| ++it; 193| 24.5k| } 194| 52.9k| } 195| 28.3k| } 196| 95.4k| }); _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 763| 448k| { 764| | if constexpr (check_quoted_num(Opts)) { 765| | if (skip_ws(ctx, it, end)) { 766| | return; 767| | } 768| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 769| | return; 770| | } 771| | } 772| | 773| | if constexpr (!check_ws_handled(Opts)) { 774| | if (skip_ws(ctx, it, end)) { 775| | return; 776| | } 777| | } 778| | 779| 448k| using V = std::decay_t; 780| 448k| if constexpr (int_t) { 781| 448k| static_assert(sizeof(*it) == sizeof(char)); 782| | 783| | if constexpr (Opts.null_terminated) { 784| | if (not glz::atoi(value, it)) [[unlikely]] { 785| | ctx.error = error_code::parse_number_failure; 786| | return; 787| | } 788| | } 789| 448k| else { 790| 448k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (790:20): [True: 4.41k, False: 444k] ------------------ 791| 4.41k| ctx.error = error_code::parse_number_failure; 792| 4.41k| return; 793| 4.41k| } 794| 448k| } 795| | } 796| | else { 797| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 798| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 799| | if constexpr (is_float128) { 800| | auto [ptr, ec] = std::from_chars(it, end, value); 801| | if (ec != std::errc()) { 802| | ctx.error = error_code::parse_number_failure; 803| | return; 804| | } 805| | it = ptr; 806| | } 807| | else 808| |#endif 809| | { 810| | if constexpr (std::is_volatile_v>) { 811| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 812| | // place 813| | V temp; 814| | if constexpr (is_size_optimized(Opts)) { 815| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 816| | if (ec != std::errc{}) [[unlikely]] { 817| | ctx.error = error_code::parse_number_failure; 818| | return; 819| | } 820| | it = ptr; 821| | } 822| | else { 823| | auto [ptr, ec] = glz::from_chars(it, end, temp); 824| | if (ec != std::errc()) [[unlikely]] { 825| | ctx.error = error_code::parse_number_failure; 826| | return; 827| | } 828| | it = ptr; 829| | } 830| | value = temp; 831| | } 832| | else { 833| | if constexpr (is_size_optimized(Opts)) { 834| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 835| | if (ec != std::errc{}) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | it = ptr; 840| | } 841| | else { 842| | auto [ptr, ec] = glz::from_chars(it, end, value); 843| | if (ec != std::errc()) [[unlikely]] { 844| | ctx.error = error_code::parse_number_failure; 845| | return; 846| | } 847| | it = ptr; 848| | } 849| | } 850| | } 851| | } 852| | 853| | if constexpr (check_quoted_num(Opts)) { 854| | if constexpr (not Opts.null_terminated) { 855| | if (it == end) [[unlikely]] { 856| | ctx.error = error_code::unexpected_end; 857| | return; 858| | } 859| | } 860| | if (match<'"'>(ctx, it)) { 861| | return; 862| | } 863| | if constexpr (not Opts.null_terminated) { 864| | if (it == end) { 865| | ctx.error = error_code::end_reached; 866| | return; 867| | } 868| | } 869| | } 870| 448k| else { 871| 448k| if constexpr (not Opts.null_terminated) { 872| 448k| if (it == end) { ------------------ | Branch (872:20): [True: 0, False: 448k] ------------------ 873| 0| ctx.error = error_code::end_reached; 874| 0| return; 875| 0| } 876| 448k| } 877| 448k| } 878| 448k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 1.37k| { 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.37k| else { 60| 1.37k| using V = std::remove_cvref_t; 61| 1.37k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.37k| end); 63| 1.37k| } 64| 1.37k| } _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 763| 1.37k| { 764| | if constexpr (check_quoted_num(Opts)) { 765| | if (skip_ws(ctx, it, end)) { 766| | return; 767| | } 768| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 769| | return; 770| | } 771| | } 772| | 773| 1.37k| if constexpr (!check_ws_handled(Opts)) { 774| 1.37k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (774:17): [True: 0, False: 1.37k] ------------------ 775| 0| return; 776| 0| } 777| 1.37k| } 778| | 779| 1.37k| using V = std::decay_t; 780| 1.37k| if constexpr (int_t) { 781| 1.37k| static_assert(sizeof(*it) == sizeof(char)); 782| | 783| | if constexpr (Opts.null_terminated) { 784| | if (not glz::atoi(value, it)) [[unlikely]] { 785| | ctx.error = error_code::parse_number_failure; 786| | return; 787| | } 788| | } 789| 1.37k| else { 790| 1.37k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (790:20): [True: 692, False: 686] ------------------ 791| 692| ctx.error = error_code::parse_number_failure; 792| 692| return; 793| 692| } 794| 1.37k| } 795| | } 796| | else { 797| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 798| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 799| | if constexpr (is_float128) { 800| | auto [ptr, ec] = std::from_chars(it, end, value); 801| | if (ec != std::errc()) { 802| | ctx.error = error_code::parse_number_failure; 803| | return; 804| | } 805| | it = ptr; 806| | } 807| | else 808| |#endif 809| | { 810| | if constexpr (std::is_volatile_v>) { 811| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 812| | // place 813| | V temp; 814| | if constexpr (is_size_optimized(Opts)) { 815| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 816| | if (ec != std::errc{}) [[unlikely]] { 817| | ctx.error = error_code::parse_number_failure; 818| | return; 819| | } 820| | it = ptr; 821| | } 822| | else { 823| | auto [ptr, ec] = glz::from_chars(it, end, temp); 824| | if (ec != std::errc()) [[unlikely]] { 825| | ctx.error = error_code::parse_number_failure; 826| | return; 827| | } 828| | it = ptr; 829| | } 830| | value = temp; 831| | } 832| | else { 833| | if constexpr (is_size_optimized(Opts)) { 834| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 835| | if (ec != std::errc{}) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | it = ptr; 840| | } 841| | else { 842| | auto [ptr, ec] = glz::from_chars(it, end, value); 843| | if (ec != std::errc()) [[unlikely]] { 844| | ctx.error = error_code::parse_number_failure; 845| | return; 846| | } 847| | it = ptr; 848| | } 849| | } 850| | } 851| | } 852| | 853| | if constexpr (check_quoted_num(Opts)) { 854| | if constexpr (not Opts.null_terminated) { 855| | if (it == end) [[unlikely]] { 856| | ctx.error = error_code::unexpected_end; 857| | return; 858| | } 859| | } 860| | if (match<'"'>(ctx, it)) { 861| | return; 862| | } 863| | if constexpr (not Opts.null_terminated) { 864| | if (it == end) { 865| | ctx.error = error_code::end_reached; 866| | return; 867| | } 868| | } 869| | } 870| 1.37k| else { 871| 1.37k| if constexpr (not Opts.null_terminated) { 872| 1.37k| if (it == end) { ------------------ | Branch (872:20): [True: 580, False: 798] ------------------ 873| 580| ctx.error = error_code::end_reached; 874| 580| return; 875| 580| } 876| 1.37k| } 877| 1.37k| } 878| 1.37k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 1.42k| { 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.42k| else { 60| 1.42k| using V = std::remove_cvref_t; 61| 1.42k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.42k| end); 63| 1.42k| } 64| 1.42k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 1.42k| { 2792| 1.42k| static constexpr auto num_members = reflect::size; 2793| | 2794| 1.42k| static constexpr auto Opts = opening_handled_off()>(); 2795| 1.42k| if constexpr (!check_opening_handled(Options)) { 2796| 1.42k| if constexpr (!check_ws_handled(Options)) { 2797| 1.42k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2797:20): [True: 0, False: 1.42k] ------------------ 2798| 0| return; 2799| 0| } 2800| 1.42k| } 2801| 1.42k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 421, False: 1.00k] ------------------ 2802| 421| return; 2803| 421| } 2804| 1.00k| if constexpr (not Opts.null_terminated) { 2805| 1.00k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 1.00k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 1.00k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 1.00k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 1.00k] ------------------ 2813| 0| return; 2814| 0| } 2815| 1.00k| } 2816| 1.00k| const auto ws_start = it; 2817| 1.42k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 1.42k] ------------------ 2818| 0| return; 2819| 0| } 2820| 1.42k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 1.42k| else { 2895| 1.42k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 1.42k| if constexpr ((glaze_object_t || reflectable) && 2897| 1.42k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 1.42k| return bit_array{}; 2899| 1.42k| } 2900| 1.42k| else { 2901| 1.42k| return nullptr; 2902| 1.42k| } 2903| 1.42k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 1.42k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 1.42k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 1.42k| return has_includer_member; 2915| 1.42k| } 2916| 1.42k| else { 2917| 1.42k| return false; 2918| 1.42k| } 2919| 1.42k| }(); 2920| 1.42k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 1.42k| [[maybe_unused]] const std::conditional_t>, 2930| 1.42k| inert_key_bits_scope> published_bits{ 2931| 1.42k| ctx, [&]() -> void* { 2932| 1.42k| if constexpr (tracks_include_keys) { 2933| 1.42k| return &fields; 2934| 1.42k| } 2935| 1.42k| else { 2936| 1.42k| return nullptr; 2937| 1.42k| } 2938| 1.42k| }()}; 2939| | 2940| 1.42k| size_t read_count{}; // for partial_read 2941| | 2942| 1.42k| bool first = true; 2943| 5.62k| while (true) { ------------------ | Branch (2943:20): [True: 4.36k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 4.36k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 118, False: 4.24k] ------------------ 2981| 118| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 118| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 118| } 3017| 118| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 118| if constexpr (not Opts.null_terminated) { 3019| 118| if (it == end) { ------------------ | Branch (3019:26): [True: 118, False: 0] ------------------ 3020| 118| ctx.error = error_code::end_reached; 3021| 118| return; 3022| 118| } 3023| 118| } 3024| 0| return; 3025| 118| } 3026| 4.24k| else if (first) { ------------------ | Branch (3026:25): [True: 970, False: 3.27k] ------------------ 3027| 970| first = false; 3028| 970| } 3029| 3.27k| else { 3030| 3.27k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 43, False: 3.23k] ------------------ 3031| 43| return; 3032| 43| } 3033| 3.23k| if constexpr (not Opts.null_terminated) { 3034| 3.23k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 3.23k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 3.23k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 3.23k| (!Opts.comments)) { 3042| 3.23k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 2.99k, False: 235] | Branch (3042:37): [True: 2.78k, False: 215] ------------------ 3043| 2.78k| skip_matching_ws(ws_start, it, ws_size); 3044| 2.78k| } 3045| 3.23k| } 3046| | 3047| 3.23k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 3.23k] ------------------ 3048| 0| return; 3049| 0| } 3050| 3.23k| } 3051| | 3052| 4.20k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 4.20k| else if constexpr (reflection_type) { 3118| 4.20k| static_assert(bool(hash_info.type)); 3119| | 3120| 4.20k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 607, False: 3.59k] ------------------ 3121| 607| ctx.error = error_code::expected_quote; 3122| 607| return; 3123| 607| } 3124| 3.59k| ++it; 3125| 3.59k| if constexpr (not Opts.null_terminated) { 3126| 3.59k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 3.59k] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 3.59k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 3.59k| else { 3181| 3.59k| parse_and_invoke(value, ctx, it, end); 3182| 3.59k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 236, False: 3.35k] ------------------ 3183| 236| return; 3184| 3.59k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 4.20k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 4.20k] ------------------ 3294| 0| return; 3295| 0| } 3296| 4.20k| } 3297| 1.42k| } 3298| 1.42k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 1.00k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 1.00k| else { 2901| 1.00k| return nullptr; 2902| 1.00k| } 2903| 1.00k| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 1.00k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 1.00k| else { 2936| 1.00k| return nullptr; 2937| 1.00k| } 2938| 1.00k| }()}; _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 382| 7.21k| { 383| 7.21k| constexpr auto N = reflect::size; 384| | 385| | if constexpr (N == 1) { 386| | decode_index(value, ctx, it, end, selected_index...); 387| | } 388| | else if constexpr (check_linear_search(Opts)) { 389| | // Linear search path 390| | auto key_start = it; 391| | const auto index = decode_linear(ctx, it, end); 392| | if (bool(ctx.error)) [[unlikely]] 393| | return; 394| | 395| | if (index >= N) [[unlikely]] { 396| | if constexpr (Opts.error_on_unknown_keys) { 397| | ctx.error = error_code::unknown_key; 398| | return; 399| | } 400| | else { 401| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 402| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 403| | return; 404| | } 405| | const sv key{key_start, size_t(it - key_start - 1)}; 406| | if constexpr (not Opts.null_terminated) { 407| | if (it == end) [[unlikely]] { 408| | ctx.error = error_code::unexpected_end; 409| | return; 410| | } 411| | } 412| | if (parse_ws_colon(ctx, it, end)) { 413| | return; 414| | } 415| | parse::handle_unknown(key, value, ctx, it, end); 416| | return; 417| | } 418| | } 419| | 420| | if constexpr (not Opts.null_terminated) { 421| | if (it == end) [[unlikely]] { 422| | ctx.error = error_code::unexpected_end; 423| | return; 424| | } 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 430| | return; 431| | } 432| | if (skip_ws(ctx, it, end)) { 433| | return; 434| | } 435| | 436| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 437| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 438| | // instantiations; the whitespace before the value has already been skipped either way. 439| | [&](std::index_sequence) { 440| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 441| | : false) || 442| | ...)); 443| | }(std::make_index_sequence{}); 444| | } 445| 7.21k| else { 446| | // Hash-based lookup 447| 7.21k| constexpr auto& HashInfo = hash_info; 448| 7.21k| constexpr auto type = HashInfo.type; 449| 7.21k| static_assert(bool(type), "invalid hash algorithm"); 450| | 451| 7.21k| const auto index = decode_hash::op(it, end); 452| | 453| 7.21k| if (index >= N) [[unlikely]] { ------------------ | Branch (453:14): [True: 0, False: 7.21k] ------------------ 454| 0| if constexpr (Opts.error_on_unknown_keys) { 455| 0| ctx.error = error_code::unknown_key; 456| 0| return; 457| | } 458| | else { 459| | auto start = it; 460| | skip_string_view(ctx, it, end); 461| | if (bool(ctx.error)) [[unlikely]] 462| | return; 463| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 464| | return; 465| | const sv key = {start, size_t(it - start)}; 466| | ++it; // skip the quote 467| | if constexpr (not Opts.null_terminated) { 468| | if (it == end) [[unlikely]] { 469| | ctx.error = error_code::unexpected_end; 470| | return; 471| | } 472| | } 473| | if (parse_ws_colon(ctx, it, end)) { 474| | return; 475| | } 476| | parse::handle_unknown(key, value, ctx, it, end); 477| | return; 478| | } 479| 0| } 480| | 481| 7.21k| if constexpr (N == 2) { 482| 7.21k| if (index == 0) { ------------------ | Branch (482:17): [True: 5.84k, False: 1.37k] ------------------ 483| 5.84k| decode_index(value, ctx, it, end, selected_index...); 484| 5.84k| } 485| 1.37k| else { 486| 1.37k| decode_index(value, ctx, it, end, selected_index...); 487| 1.37k| } 488| | } 489| | else { 490| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 491| | } 492| 7.21k| } 493| 7.21k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 312| 5.84k| { 313| 5.84k| static constexpr auto Key = get(reflect::keys); 314| 5.84k| static constexpr auto KeyWithEndQuote = join_v>; 315| 5.84k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 5.84k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 5.84k, False: 0] | Branch (321:52): [True: 5.81k, False: 23] ------------------ 322| 5.81k| it += Length; 323| 5.81k| if constexpr (not Opts.null_terminated) { 324| 5.81k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 5.81k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 5.81k| } 329| | 330| 5.81k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 5.81k] ------------------ 331| 0| return; 332| 0| } 333| 5.81k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 49, False: 5.76k] ------------------ 334| 49| return; 335| 49| } 336| 5.76k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 5.76k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 5.76k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 5.76k| } 343| 23| else [[unlikely]] { 344| 23| decode_index_unknown_key(value, ctx, it, end); 345| 23| } 346| 5.84k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 5.76k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 5.76k| else { 274| 5.76k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 5.76k| else { 298| 5.76k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 5.76k| it, end); 300| 5.76k| } 301| 5.76k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 5.76k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 763| 1.28M| { 764| | if constexpr (check_quoted_num(Opts)) { 765| | if (skip_ws(ctx, it, end)) { 766| | return; 767| | } 768| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 769| | return; 770| | } 771| | } 772| | 773| | if constexpr (!check_ws_handled(Opts)) { 774| | if (skip_ws(ctx, it, end)) { 775| | return; 776| | } 777| | } 778| | 779| 1.28M| using V = std::decay_t; 780| | if constexpr (int_t) { 781| | static_assert(sizeof(*it) == sizeof(char)); 782| | 783| | if constexpr (Opts.null_terminated) { 784| | if (not glz::atoi(value, it)) [[unlikely]] { 785| | ctx.error = error_code::parse_number_failure; 786| | return; 787| | } 788| | } 789| | else { 790| | if (not glz::atoi(value, it, end)) [[unlikely]] { 791| | ctx.error = error_code::parse_number_failure; 792| | return; 793| | } 794| | } 795| | } 796| 1.28M| else { 797| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 798| 1.28M|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 799| | if constexpr (is_float128) { 800| | auto [ptr, ec] = std::from_chars(it, end, value); 801| | if (ec != std::errc()) { 802| | ctx.error = error_code::parse_number_failure; 803| | return; 804| | } 805| | it = ptr; 806| | } 807| | else 808| |#endif 809| 1.28M| { 810| | if constexpr (std::is_volatile_v>) { 811| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 812| | // place 813| | V temp; 814| | if constexpr (is_size_optimized(Opts)) { 815| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 816| | if (ec != std::errc{}) [[unlikely]] { 817| | ctx.error = error_code::parse_number_failure; 818| | return; 819| | } 820| | it = ptr; 821| | } 822| | else { 823| | auto [ptr, ec] = glz::from_chars(it, end, temp); 824| | if (ec != std::errc()) [[unlikely]] { 825| | ctx.error = error_code::parse_number_failure; 826| | return; 827| | } 828| | it = ptr; 829| | } 830| | value = temp; 831| | } 832| 1.28M| else { 833| | if constexpr (is_size_optimized(Opts)) { 834| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 835| | if (ec != std::errc{}) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | it = ptr; 840| | } 841| 1.28M| else { 842| 1.28M| auto [ptr, ec] = glz::from_chars(it, end, value); 843| 1.28M| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (843:26): [True: 1.09k, False: 1.28M] ------------------ 844| 1.09k| ctx.error = error_code::parse_number_failure; 845| 1.09k| return; 846| 1.09k| } 847| 1.28M| it = ptr; 848| 1.28M| } 849| 1.28M| } 850| 1.28M| } 851| 1.28M| } 852| | 853| | if constexpr (check_quoted_num(Opts)) { 854| | if constexpr (not Opts.null_terminated) { 855| | if (it == end) [[unlikely]] { 856| | ctx.error = error_code::unexpected_end; 857| | return; 858| | } 859| | } 860| | if (match<'"'>(ctx, it)) { 861| | return; 862| | } 863| | if constexpr (not Opts.null_terminated) { 864| | if (it == end) { 865| | ctx.error = error_code::end_reached; 866| | return; 867| | } 868| | } 869| | } 870| 1.28M| else { 871| 1.28M| if constexpr (not Opts.null_terminated) { 872| 1.28M| if (it == end) { ------------------ | Branch (872:20): [True: 0, False: 1.28M] ------------------ 873| 0| ctx.error = error_code::end_reached; 874| 0| return; 875| 0| } 876| 1.28M| } 877| 1.28M| } 878| 1.28M| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 142| { 178| 142| if constexpr (Opts.error_on_unknown_keys) { 179| 142| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | uint64_t ascii_acc{}; 184| | skip_string_view(ctx, it, end, ascii_acc); 185| | if (bool(ctx.error)) [[unlikely]] 186| | return; 187| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 188| | return; 189| | const sv key = {start, size_t(it - start)}; 190| | ++it; 191| | if constexpr (not Opts.null_terminated) { 192| | if (it == end) [[unlikely]] { 193| | ctx.error = error_code::unexpected_end; 194| | return; 195| | } 196| | } 197| | 198| | if (parse_ws_colon(ctx, it, end)) { 199| | return; 200| | } 201| | 202| | parse::handle_unknown(key, value, ctx, it, end); 203| | } 204| 142| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 312| 1.37k| { 313| 1.37k| static constexpr auto Key = get(reflect::keys); 314| 1.37k| static constexpr auto KeyWithEndQuote = join_v>; 315| 1.37k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 1.37k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 1.36k, False: 6] | Branch (321:52): [True: 1.25k, False: 113] ------------------ 322| 1.25k| it += Length; 323| 1.25k| if constexpr (not Opts.null_terminated) { 324| 1.25k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 1.25k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 1.25k| } 329| | 330| 1.25k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 1.25k] ------------------ 331| 0| return; 332| 0| } 333| 1.25k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 33, False: 1.22k] ------------------ 334| 33| return; 335| 33| } 336| 1.22k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 1.22k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 1.22k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 1.22k| } 343| 119| else [[unlikely]] { 344| 119| decode_index_unknown_key(value, ctx, it, end); 345| 119| } 346| 1.37k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 1.22k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 1.22k| else { 274| 1.22k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 1.22k| else { 298| 1.22k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 1.22k| it, end); 300| 1.22k| } 301| 1.22k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 1.22k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 8.99k| { 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.99k| else { 60| 8.99k| using V = std::remove_cvref_t; 61| 8.99k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 8.99k| end); 63| 8.99k| } 64| 8.99k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 8.99k| { 2792| 8.99k| static constexpr auto num_members = reflect::size; 2793| | 2794| 8.99k| static constexpr auto Opts = opening_handled_off()>(); 2795| 8.99k| if constexpr (!check_opening_handled(Options)) { 2796| 8.99k| if constexpr (!check_ws_handled(Options)) { 2797| 8.99k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2797:20): [True: 0, False: 8.99k] ------------------ 2798| 0| return; 2799| 0| } 2800| 8.99k| } 2801| 8.99k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 88, False: 8.90k] ------------------ 2802| 88| return; 2803| 88| } 2804| 8.90k| if constexpr (not Opts.null_terminated) { 2805| 8.90k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 8.90k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 8.90k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 8.90k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 8.90k] ------------------ 2813| 0| return; 2814| 0| } 2815| 8.90k| } 2816| 8.90k| const auto ws_start = it; 2817| 8.99k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 8.99k] ------------------ 2818| 0| return; 2819| 0| } 2820| 8.99k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 8.99k| else { 2895| 8.99k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 8.99k| if constexpr ((glaze_object_t || reflectable) && 2897| 8.99k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 8.99k| return bit_array{}; 2899| 8.99k| } 2900| 8.99k| else { 2901| 8.99k| return nullptr; 2902| 8.99k| } 2903| 8.99k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 8.99k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 8.99k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 8.99k| return has_includer_member; 2915| 8.99k| } 2916| 8.99k| else { 2917| 8.99k| return false; 2918| 8.99k| } 2919| 8.99k| }(); 2920| 8.99k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 8.99k| [[maybe_unused]] const std::conditional_t>, 2930| 8.99k| inert_key_bits_scope> published_bits{ 2931| 8.99k| ctx, [&]() -> void* { 2932| 8.99k| if constexpr (tracks_include_keys) { 2933| 8.99k| return &fields; 2934| 8.99k| } 2935| 8.99k| else { 2936| 8.99k| return nullptr; 2937| 8.99k| } 2938| 8.99k| }()}; 2939| | 2940| 8.99k| size_t read_count{}; // for partial_read 2941| | 2942| 8.99k| bool first = true; 2943| 43.4k| while (true) { ------------------ | Branch (2943:20): [True: 35.8k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 35.8k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 1.01k, False: 34.8k] ------------------ 2981| 1.01k| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 1.01k| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 1.01k| } 3017| 1.01k| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 1.01k| if constexpr (not Opts.null_terminated) { 3019| 1.01k| if (it == end) { ------------------ | Branch (3019:26): [True: 1.01k, False: 0] ------------------ 3020| 1.01k| ctx.error = error_code::end_reached; 3021| 1.01k| return; 3022| 1.01k| } 3023| 1.01k| } 3024| 0| return; 3025| 1.01k| } 3026| 34.8k| else if (first) { ------------------ | Branch (3026:25): [True: 8.87k, False: 25.9k] ------------------ 3027| 8.87k| first = false; 3028| 8.87k| } 3029| 25.9k| else { 3030| 25.9k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 364, False: 25.6k] ------------------ 3031| 364| return; 3032| 364| } 3033| 25.6k| if constexpr (not Opts.null_terminated) { 3034| 25.6k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 25.6k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 25.6k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 25.6k| (!Opts.comments)) { 3042| 25.6k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 13.1k, False: 12.4k] | Branch (3042:37): [True: 12.9k, False: 247] ------------------ 3043| 12.9k| skip_matching_ws(ws_start, it, ws_size); 3044| 12.9k| } 3045| 25.6k| } 3046| | 3047| 25.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 25.6k] ------------------ 3048| 0| return; 3049| 0| } 3050| 25.6k| } 3051| | 3052| 34.4k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 34.4k| else if constexpr (reflection_type) { 3118| 34.4k| static_assert(bool(hash_info.type)); 3119| | 3120| 34.4k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 771, False: 33.7k] ------------------ 3121| 771| ctx.error = error_code::expected_quote; 3122| 771| return; 3123| 771| } 3124| 33.7k| ++it; 3125| 33.7k| if constexpr (not Opts.null_terminated) { 3126| 33.7k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 33.7k] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 33.7k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 33.7k| else { 3181| 33.7k| parse_and_invoke(value, ctx, it, end); 3182| 33.7k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 6.75k, False: 26.9k] ------------------ 3183| 6.75k| return; 3184| 33.7k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 34.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 34.4k] ------------------ 3294| 0| return; 3295| 0| } 3296| 34.4k| } 3297| 8.99k| } 3298| 8.99k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 8.90k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 8.90k| else { 2901| 8.90k| return nullptr; 2902| 8.90k| } 2903| 8.90k| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 8.90k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 8.90k| else { 2936| 8.90k| return nullptr; 2937| 8.90k| } 2938| 8.90k| }()}; _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 382| 33.7k| { 383| 33.7k| constexpr auto N = reflect::size; 384| | 385| | if constexpr (N == 1) { 386| | decode_index(value, ctx, it, end, selected_index...); 387| | } 388| | else if constexpr (check_linear_search(Opts)) { 389| | // Linear search path 390| | auto key_start = it; 391| | const auto index = decode_linear(ctx, it, end); 392| | if (bool(ctx.error)) [[unlikely]] 393| | return; 394| | 395| | if (index >= N) [[unlikely]] { 396| | if constexpr (Opts.error_on_unknown_keys) { 397| | ctx.error = error_code::unknown_key; 398| | return; 399| | } 400| | else { 401| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 402| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 403| | return; 404| | } 405| | const sv key{key_start, size_t(it - key_start - 1)}; 406| | if constexpr (not Opts.null_terminated) { 407| | if (it == end) [[unlikely]] { 408| | ctx.error = error_code::unexpected_end; 409| | return; 410| | } 411| | } 412| | if (parse_ws_colon(ctx, it, end)) { 413| | return; 414| | } 415| | parse::handle_unknown(key, value, ctx, it, end); 416| | return; 417| | } 418| | } 419| | 420| | if constexpr (not Opts.null_terminated) { 421| | if (it == end) [[unlikely]] { 422| | ctx.error = error_code::unexpected_end; 423| | return; 424| | } 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 430| | return; 431| | } 432| | if (skip_ws(ctx, it, end)) { 433| | return; 434| | } 435| | 436| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 437| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 438| | // instantiations; the whitespace before the value has already been skipped either way. 439| | [&](std::index_sequence) { 440| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 441| | : false) || 442| | ...)); 443| | }(std::make_index_sequence{}); 444| | } 445| 33.7k| else { 446| | // Hash-based lookup 447| 33.7k| constexpr auto& HashInfo = hash_info; 448| 33.7k| constexpr auto type = HashInfo.type; 449| 33.7k| static_assert(bool(type), "invalid hash algorithm"); 450| | 451| 33.7k| const auto index = decode_hash::op(it, end); 452| | 453| 33.7k| if (index >= N) [[unlikely]] { ------------------ | Branch (453:14): [True: 125, False: 33.5k] ------------------ 454| 125| if constexpr (Opts.error_on_unknown_keys) { 455| 125| ctx.error = error_code::unknown_key; 456| 125| return; 457| | } 458| | else { 459| | auto start = it; 460| | skip_string_view(ctx, it, end); 461| | if (bool(ctx.error)) [[unlikely]] 462| | return; 463| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 464| | return; 465| | const sv key = {start, size_t(it - start)}; 466| | ++it; // skip the quote 467| | if constexpr (not Opts.null_terminated) { 468| | if (it == end) [[unlikely]] { 469| | ctx.error = error_code::unexpected_end; 470| | return; 471| | } 472| | } 473| | if (parse_ws_colon(ctx, it, end)) { 474| | return; 475| | } 476| | parse::handle_unknown(key, value, ctx, it, end); 477| | return; 478| | } 479| 125| } 480| | 481| | if constexpr (N == 2) { 482| | if (index == 0) { 483| | decode_index(value, ctx, it, end, selected_index...); 484| | } 485| | else { 486| | decode_index(value, ctx, it, end, selected_index...); 487| | } 488| | } 489| 33.7k| else { 490| 33.7k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 491| 33.7k| } 492| 33.7k| } 493| 33.7k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav: 490| 17.4k| 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_: 312| 17.4k| { 313| 17.4k| static constexpr auto Key = get(reflect::keys); 314| 17.4k| static constexpr auto KeyWithEndQuote = join_v>; 315| 17.4k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 17.4k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 17.4k, False: 3] | Branch (321:52): [True: 17.4k, False: 25] ------------------ 322| 17.4k| it += Length; 323| 17.4k| if constexpr (not Opts.null_terminated) { 324| 17.4k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 17.4k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 17.4k| } 329| | 330| 17.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 17.4k] ------------------ 331| 0| return; 332| 0| } 333| 17.4k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 48, False: 17.3k] ------------------ 334| 48| return; 335| 48| } 336| 17.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 17.3k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 17.3k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 17.3k| } 343| 28| else [[unlikely]] { 344| 28| decode_index_unknown_key(value, ctx, it, end); 345| 28| } 346| 17.4k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 17.3k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 17.3k| else { 274| 17.3k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 17.3k| else { 298| 17.3k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 17.3k| it, end); 300| 17.3k| } 301| 17.3k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 17.3k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 616| { 178| 616| if constexpr (Opts.error_on_unknown_keys) { 179| 616| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | uint64_t ascii_acc{}; 184| | skip_string_view(ctx, it, end, ascii_acc); 185| | if (bool(ctx.error)) [[unlikely]] 186| | return; 187| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 188| | return; 189| | const sv key = {start, size_t(it - start)}; 190| | ++it; 191| | if constexpr (not Opts.null_terminated) { 192| | if (it == end) [[unlikely]] { 193| | ctx.error = error_code::unexpected_end; 194| | return; 195| | } 196| | } 197| | 198| | if (parse_ws_colon(ctx, it, end)) { 199| | return; 200| | } 201| | 202| | parse::handle_unknown(key, value, ctx, it, end); 203| | } 204| 616| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav: 490| 139| 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_: 312| 139| { 313| 139| static constexpr auto Key = get(reflect::keys); 314| 139| static constexpr auto KeyWithEndQuote = join_v>; 315| 139| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 139| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 136, False: 3] | Branch (321:52): [True: 72, False: 64] ------------------ 322| 72| it += Length; 323| 72| if constexpr (not Opts.null_terminated) { 324| 72| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 72] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 72| } 329| | 330| 72| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 72] ------------------ 331| 0| return; 332| 0| } 333| 72| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 22, False: 50] ------------------ 334| 22| return; 335| 22| } 336| 50| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 50] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 50| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 50| } 343| 67| else [[unlikely]] { 344| 67| decode_index_unknown_key(value, ctx, it, end); 345| 67| } 346| 139| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 50| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 50| else { 274| 50| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 50| else { 298| 50| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 50| it, end); 300| 50| } 301| 50| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 50| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEEEvRT2_OT3_OT0_T1_: 887| 1.65M| { 888| | if constexpr (check_string_as_number(Opts)) { 889| | auto start = it; 890| | skip_number(ctx, it, end); 891| | if (bool(ctx.error)) [[unlikely]] { 892| | return; 893| | } 894| | if (start == it) [[unlikely]] { 895| | ctx.error = error_code::parse_number_failure; 896| | return; 897| | } 898| | value.append(start, size_t(it - start)); 899| | } 900| 1.65M| else { 901| 1.65M| if constexpr (!check_opening_handled(Opts)) { 902| | if constexpr (!check_ws_handled(Opts)) { 903| | if (skip_ws(ctx, it, end)) { 904| | return; 905| | } 906| | } 907| | 908| 1.65M| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (908:20): [True: 103, False: 1.65M] ------------------ 909| 103| return; 910| 103| } 911| 1.65M| } 912| | 913| 1.65M| if constexpr (not check_raw_string(Opts)) { 914| 1.65M| static constexpr auto string_padding_bytes = 8; 915| | 916| | // How much buffer has to remain for an eight byte load at the cursor to stay inside 917| | // it. One on a padded input, where the last chunk is free to straddle the end of the 918| | // document, so the byte tails below are unreachable; eight otherwise, which costs the 919| | // final bytes of the buffer their chunked path and nothing else. 920| 1.65M| const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 921| | 922| 1.65M| if (size_t(end - it) >= 8) { ------------------ | Branch (922:20): [True: 1.65M, False: 513] ------------------ 923| | // The bound as a pointer, so the loops below spend a compare per chunk rather 924| | // than a subtract and a compare. Well defined here and nowhere else in this 925| | // reader: the branch has just established that at least eight bytes remain, and 926| | // `scan_min` is at most eight. 927| 1.65M| const auto* const chunk_limit = end - scan_min; 928| | 929| 1.65M| auto start = it; 930| 1.65M| uint64_t ascii_acc{}; 931| 13.1M| while (it <= chunk_limit) { ------------------ | Branch (931:26): [True: 13.1M, False: 848] ------------------ 932| 13.1M| uint64_t chunk; 933| 13.1M| std::memcpy(&chunk, it, 8); 934| | if constexpr (std::endian::native == std::endian::big) { 935| | chunk = std::byteswap(chunk); 936| | } 937| 13.1M| ascii_acc |= chunk; 938| 13.1M| const uint64_t test_chars = has_quote(chunk); 939| 13.1M| if (test_chars) { ------------------ | Branch (939:26): [True: 1.98M, False: 11.1M] ------------------ 940| 1.98M| it += (countr_zero(test_chars) >> 3); 941| | 942| 1.98M| auto* prev = it - 1; 943| 2.35M| while (*prev == '\\') { ------------------ | Branch (943:32): [True: 377k, False: 1.98M] ------------------ 944| 377k| --prev; 945| 377k| } 946| 1.98M| if (size_t(it - prev) % 2) { ------------------ | Branch (946:29): [True: 1.65M, False: 323k] ------------------ 947| 1.65M| goto continue_decode; 948| 1.65M| } 949| 323k| ++it; // skip the escaped quote 950| 323k| } 951| 11.1M| else { 952| 11.1M| it += 8; 953| 11.1M| } 954| 13.1M| } 955| | 956| 7.25k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (956:26): [True: 6.40k, False: 848] ------------------ 957| | // if we ended on an escape character then we need to rewind 958| | // because we lost our context 959| 6.40k| --it; 960| 6.40k| } 961| | 962| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 963| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 964| 9.40k| for (; it < end; ++it) { ------------------ | Branch (964:26): [True: 9.40k, False: 0] ------------------ 965| 9.40k| ascii_acc |= uint8_t(*it); 966| 9.40k| if (*it == '"') { ------------------ | Branch (966:26): [True: 871, False: 8.53k] ------------------ 967| 871| auto* prev = it - 1; 968| 7.05k| while (*prev == '\\') { ------------------ | Branch (968:32): [True: 6.18k, False: 871] ------------------ 969| 6.18k| --prev; 970| 6.18k| } 971| 871| if (size_t(it - prev) % 2) { ------------------ | Branch (971:29): [True: 848, False: 23] ------------------ 972| 848| goto continue_decode; 973| 848| } 974| 871| } 975| 9.40k| } 976| | 977| 0| ctx.error = error_code::unexpected_end; 978| 0| return; 979| | 980| 1.65M| continue_decode: 981| | 982| 1.65M| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (982:23): [True: 15.9k, False: 1.64M] ------------------ 983| 15.9k| return; 984| 15.9k| } 985| | 986| 1.64M| auto n = size_t(it - start); 987| | 988| | // The padding lets the chunked copy below run up to the closing quote. Skip it when it 989| | // would be the only reason to allocate, as for a string that fits the small string 990| | // buffer but not with eight bytes to spare. 991| 1.64M| bool pad = true; 992| 1.64M| if constexpr (requires { value.capacity(); }) { 993| 1.64M| const auto capacity = size_t(value.capacity()); 994| 1.64M| pad = capacity >= n + string_padding_bytes || capacity < n; ------------------ | Branch (994:28): [True: 1.04M, False: 600k] | Branch (994:68): [True: 123k, False: 477k] ------------------ 995| 1.64M| } 996| 1.64M| resize_unfilled(value, pad ? n + string_padding_bytes : n); ------------------ | Branch (996:42): [True: 1.16M, False: 477k] ------------------ 997| | 998| 1.64M| auto* p = value.data(); 999| | 1000| | // An error below returns with the tail of `value` still unwritten. Leave the size at 1001| | // what was actually written rather than at the padded length, which resize_unfilled 1002| | // did not fill. 1003| 1.64M| auto* const written_begin = p; 1004| | 1005| | // Without the padding, copy a chunk only while eight bytes remain before the quote. 1006| | // Unescaping never puts the output ahead of the input, so no store lands past the end. 1007| 1.64M| const auto* const copy_end = pad ? it : it - (std::min)(n, size_t(7)); ------------------ | Branch (1007:48): [True: 1.16M, False: 477k] ------------------ 1008| | 1009| | // Copy eight bytes at a time for as long as eight bytes are there to read, then 1010| | // finish the span below. The chunked form reads past the character it is looking 1011| | // at, so on an unpadded buffer it has to stop short of the end; splitting it this 1012| | // way keeps it for the body of every string rather than giving it up whenever the 1013| | // string happens to finish near the end of the buffer -- which, for a document 1014| | // that is itself one string, is every string. 1015| 9.45M| while (start < copy_end && start <= chunk_limit) { ------------------ | Branch (1015:26): [True: 7.81M, False: 1.63M] | Branch (1015:46): [True: 7.81M, False: 409] ------------------ 1016| 7.81M| std::memcpy(p, start, 8); 1017| 7.81M| uint64_t swar; 1018| 7.81M| std::memcpy(&swar, p, 8); 1019| | if constexpr (std::endian::native == std::endian::big) { 1020| | swar = std::byteswap(swar); 1021| | } 1022| | 1023| 7.81M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1024| 7.81M| const uint64_t lo7 = swar & lo7_mask; 1025| 7.81M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1026| 7.81M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1027| 7.81M| uint64_t next = ~((backslash & less_32) | swar); 1028| | 1029| 7.81M| next &= repeat_byte8(0b10000000); 1030| 7.81M| if (next == 0) { ------------------ | Branch (1030:26): [True: 7.21M, False: 607k] ------------------ 1031| 7.21M| start += 8; 1032| 7.21M| p += 8; 1033| 7.21M| continue; 1034| 7.21M| } 1035| | 1036| 607k| next = countr_zero(next) >> 3; 1037| 607k| start += next; 1038| 607k| if (start >= it) { ------------------ | Branch (1038:26): [True: 472, False: 606k] ------------------ 1039| 472| break; 1040| 472| } 1041| | 1042| 606k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1042:26): [True: 10.0k, False: 596k] ------------------ 1043| 10.0k| ctx.error = error_code::syntax_error; 1044| 10.0k| value.resize(size_t(p - written_begin)); 1045| 10.0k| return; 1046| 10.0k| } 1047| 596k| ++start; // skip the escape 1048| 596k| if (*start == 'u') { ------------------ | Branch (1048:26): [True: 1.91k, False: 594k] ------------------ 1049| 1.91k| ++start; 1050| 1.91k| p += next; 1051| 1.91k| const auto mark = start; 1052| 1.91k| const auto decoded = handle_unicode_code_point(start, p, end); 1053| 1.91k| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1053:29): [True: 145, False: 1.77k] ------------------ 1054| 145| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1054:40): [True: 0, False: 145] ------------------ 1055| 145| : error_code::unicode_escape_conversion_failure; 1056| 145| value.resize(size_t(p - written_begin)); 1057| 145| return; 1058| 145| } 1059| 1.77k| n += decoded.written; 1060| | // escape + u + unicode code points 1061| 1.77k| n -= 2 + uint32_t(start - mark); 1062| 1.77k| } 1063| 594k| else { 1064| 594k| p += next; 1065| 594k| *p = char_unescape_table[uint8_t(*start)]; 1066| 594k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1066:29): [True: 22, False: 594k] ------------------ 1067| 22| ctx.error = error_code::invalid_escape; 1068| 22| value.resize(size_t(p - written_begin)); 1069| 22| return; 1070| 22| } 1071| 594k| ++p; 1072| 594k| ++start; 1073| 594k| --n; 1074| 594k| } 1075| 596k| } 1076| | 1077| | // Whatever the chunked copy could not reach. `p` and `start` stay in step across 1078| | // that loop, so this picks up exactly where it stopped. 1079| 4.55M| while (start < it) { ------------------ | Branch (1079:26): [True: 2.92M, False: 1.63M] ------------------ 1080| 2.92M| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1080:26): [True: 97, False: 2.92M] ------------------ 1081| 97| ctx.error = error_code::syntax_error; 1082| 97| value.resize(size_t(p - written_begin)); 1083| 97| return; 1084| 97| } 1085| 2.92M| if (*start == '\\') { ------------------ | Branch (1085:26): [True: 706, False: 2.92M] ------------------ 1086| 706| ++start; // skip the escape 1087| 706| if (*start == 'u') { ------------------ | Branch (1087:29): [True: 98, False: 608] ------------------ 1088| 98| ++start; 1089| 98| const auto mark = start; 1090| 98| const auto decoded = handle_unicode_code_point(start, p, end); 1091| 98| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1091:32): [True: 43, False: 55] ------------------ 1092| 43| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1092:43): [True: 0, False: 43] ------------------ 1093| 43| : error_code::unicode_escape_conversion_failure; 1094| 43| value.resize(size_t(p - written_begin)); 1095| 43| return; 1096| 43| } 1097| 55| n += decoded.written; 1098| 55| n -= 2 + uint32_t(start - mark); 1099| 55| } 1100| 608| else { 1101| 608| *p = char_unescape_table[uint8_t(*start)]; 1102| 608| if (*p == 0) [[unlikely]] { ------------------ | Branch (1102:32): [True: 7, False: 601] ------------------ 1103| 7| ctx.error = error_code::invalid_escape; 1104| 7| value.resize(size_t(p - written_begin)); 1105| 7| return; 1106| 7| } 1107| 601| ++p; 1108| 601| ++start; 1109| 601| --n; 1110| 601| } 1111| 706| } 1112| 2.92M| else { 1113| 2.92M| *p = *start; 1114| 2.92M| ++p; 1115| 2.92M| ++start; 1116| 2.92M| } 1117| 2.92M| } 1118| | 1119| 1.63M| value.resize(n); 1120| 1.63M| ++it; 1121| 1.63M| } 1122| 513| else { 1123| | // For short strings 1124| | 1125| 513| std::array buffer{}; 1126| | 1127| 513| auto* p = buffer.data(); 1128| 513| const auto* const utf8_start = it; 1129| | 1130| 1.16k| while (it < end) [[likely]] { ------------------ | Branch (1130:26): [True: 1.06k, False: 103] ------------------ 1131| 1.06k| *p = *it; 1132| 1.06k| if (*it == '"') { ------------------ | Branch (1132:26): [True: 333, False: 732] ------------------ 1133| 333| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1133:29): [True: 0, False: 333] ------------------ 1134| 0| return; 1135| 0| } 1136| 333| const size_t n = size_t(p - buffer.data()); 1137| 333|#if __has_cpp_attribute(assume) >= 202207L 1138| 333| [[assume(n <= sizeof(buffer))]]; 1139| 333|#endif 1140| 333| value.assign(buffer.data(), n); 1141| 333| ++it; 1142| 333| if constexpr (not Opts.null_terminated) { 1143| 333| if (it == end) { ------------------ | Branch (1143:32): [True: 214, False: 119] ------------------ 1144| 214| ctx.error = error_code::end_reached; 1145| 214| return; 1146| 214| } 1147| 333| } 1148| 119| return; 1149| 333| } 1150| 732| else if (*it == '\\') { ------------------ | Branch (1150:31): [True: 171, False: 561] ------------------ 1151| | // Bounded whatever `null_terminated` says: a document cut off inside an 1152| | // escape has run out of input, and saying so beats blaming the terminator 1153| | // the cut exposed -- which is what reading on would find, and would report 1154| | // as a malformed escape. 1155| 171| ++it; // skip the escape 1156| 171| if (it == end) [[unlikely]] { ------------------ | Branch (1156:29): [True: 0, False: 171] ------------------ 1157| 0| ctx.error = error_code::unexpected_end; 1158| 0| return; 1159| 0| } 1160| 171| if (*it == 'u') { ------------------ | Branch (1160:29): [True: 103, False: 68] ------------------ 1161| 103| ++it; 1162| 103| if (it == end) [[unlikely]] { ------------------ | Branch (1162:32): [True: 0, False: 103] ------------------ 1163| 0| ctx.error = error_code::unexpected_end; 1164| 0| return; 1165| 0| } 1166| 103| const auto decoded = handle_unicode_code_point(it, p, end); 1167| 103| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1167:32): [True: 34, False: 69] ------------------ 1168| 34| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1168:43): [True: 0, False: 34] ------------------ 1169| 34| : error_code::unicode_escape_conversion_failure; 1170| 34| return; 1171| 34| } 1172| 103| } 1173| 68| else { 1174| 68| *p = char_unescape_table[uint8_t(*it)]; 1175| 68| if (*p == 0) [[unlikely]] { ------------------ | Branch (1175:32): [True: 11, False: 57] ------------------ 1176| 11| ctx.error = error_code::invalid_escape; 1177| 11| return; 1178| 11| } 1179| 57| ++p; 1180| 57| ++it; 1181| 57| } 1182| 171| } 1183| 561| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1183:31): [True: 32, False: 529] ------------------ 1184| 32| ctx.error = error_code::syntax_error; 1185| 32| return; 1186| 32| } 1187| 529| else { 1188| 529| ++it; 1189| 529| ++p; 1190| 529| } 1191| 1.06k| } 1192| | 1193| 103| ctx.error = error_code::unexpected_end; 1194| 103| } 1195| | } 1196| | else { 1197| | // raw_string 1198| | auto start = it; 1199| | skip_string_view(ctx, it, end); 1200| | if (bool(ctx.error)) [[unlikely]] 1201| | return; 1202| | 1203| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1204| | return; 1205| | } 1206| | 1207| | value.assign(start, size_t(it - start)); 1208| | ++it; 1209| | } 1210| 1.65M| } 1211| 1.65M| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav: 490| 908| 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_: 312| 908| { 313| 908| static constexpr auto Key = get(reflect::keys); 314| 908| static constexpr auto KeyWithEndQuote = join_v>; 315| 908| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 908| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 904, False: 4] | Branch (321:52): [True: 878, False: 26] ------------------ 322| 878| it += Length; 323| 878| if constexpr (not Opts.null_terminated) { 324| 878| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 878] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 878| } 329| | 330| 878| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 878] ------------------ 331| 0| return; 332| 0| } 333| 878| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 29, False: 849] ------------------ 334| 29| return; 335| 29| } 336| 849| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 849] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 849| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 849| } 343| 30| else [[unlikely]] { 344| 30| decode_index_unknown_key(value, ctx, it, end); 345| 30| } 346| 908| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 849| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 849| else { 274| 849| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 849| else { 298| 849| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 849| it, end); 300| 849| } 301| 849| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 849| } _ZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 849| { 2792| 849| static constexpr auto num_members = reflect::size; 2793| | 2794| 849| static constexpr auto Opts = opening_handled_off()>(); 2795| 849| if constexpr (!check_opening_handled(Options)) { 2796| | if constexpr (!check_ws_handled(Options)) { 2797| | if (skip_ws(ctx, it, end)) { 2798| | return; 2799| | } 2800| | } 2801| 849| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 26, False: 823] ------------------ 2802| 26| return; 2803| 26| } 2804| 823| if constexpr (not Opts.null_terminated) { 2805| 823| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 823] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 823| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 823| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 823] ------------------ 2813| 0| return; 2814| 0| } 2815| 823| } 2816| 823| const auto ws_start = it; 2817| 849| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 849] ------------------ 2818| 0| return; 2819| 0| } 2820| 849| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 849| else { 2895| 849| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 849| if constexpr ((glaze_object_t || reflectable) && 2897| 849| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 849| return bit_array{}; 2899| 849| } 2900| 849| else { 2901| 849| return nullptr; 2902| 849| } 2903| 849| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 849| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 849| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 849| return has_includer_member; 2915| 849| } 2916| 849| else { 2917| 849| return false; 2918| 849| } 2919| 849| }(); 2920| 849| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 849| [[maybe_unused]] const std::conditional_t>, 2930| 849| inert_key_bits_scope> published_bits{ 2931| 849| ctx, [&]() -> void* { 2932| 849| if constexpr (tracks_include_keys) { 2933| 849| return &fields; 2934| 849| } 2935| 849| else { 2936| 849| return nullptr; 2937| 849| } 2938| 849| }()}; 2939| | 2940| 849| size_t read_count{}; // for partial_read 2941| | 2942| 849| bool first = true; 2943| 5.08k| while (true) { ------------------ | Branch (2943:20): [True: 4.38k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 4.38k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 132, False: 4.25k] ------------------ 2981| 132| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 132| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 132| } 3017| 132| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 132| if constexpr (not Opts.null_terminated) { 3019| 132| if (it == end) { ------------------ | Branch (3019:26): [True: 0, False: 132] ------------------ 3020| 0| ctx.error = error_code::end_reached; 3021| 0| return; 3022| 0| } 3023| 132| } 3024| 132| return; 3025| 132| } 3026| 4.25k| else if (first) { ------------------ | Branch (3026:25): [True: 760, False: 3.49k] ------------------ 3027| 760| first = false; 3028| 760| } 3029| 3.49k| else { 3030| 3.49k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 23, False: 3.47k] ------------------ 3031| 23| return; 3032| 23| } 3033| 3.47k| if constexpr (not Opts.null_terminated) { 3034| 3.47k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 3.47k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 3.47k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 3.47k| (!Opts.comments)) { 3042| 3.47k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 3.25k, False: 218] | Branch (3042:37): [True: 2.43k, False: 818] ------------------ 3043| 2.43k| skip_matching_ws(ws_start, it, ws_size); 3044| 2.43k| } 3045| 3.47k| } 3046| | 3047| 3.47k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 3.47k] ------------------ 3048| 0| return; 3049| 0| } 3050| 3.47k| } 3051| | 3052| 4.23k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 4.23k| else if constexpr (reflection_type) { 3118| 4.23k| static_assert(bool(hash_info.type)); 3119| | 3120| 4.23k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 611, False: 3.62k] ------------------ 3121| 611| ctx.error = error_code::expected_quote; 3122| 611| return; 3123| 611| } 3124| 3.62k| ++it; 3125| 3.62k| if constexpr (not Opts.null_terminated) { 3126| 3.62k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 3.62k] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 3.62k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 3.62k| else { 3181| 3.62k| parse_and_invoke(value, ctx, it, end); 3182| 3.62k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 57, False: 3.56k] ------------------ 3183| 57| return; 3184| 3.62k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 4.23k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 4.23k] ------------------ 3294| 0| return; 3295| 0| } 3296| 4.23k| } 3297| 849| } 3298| 849| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 823| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 823| else { 2901| 823| return nullptr; 2902| 823| } 2903| 823| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 823| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 823| else { 2936| 823| return nullptr; 2937| 823| } 2938| 823| }()}; _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav: 490| 731| 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_: 312| 731| { 313| 731| static constexpr auto Key = get(reflect::keys); 314| 731| static constexpr auto KeyWithEndQuote = join_v>; 315| 731| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 731| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 722, False: 9] | Branch (321:52): [True: 706, False: 16] ------------------ 322| 706| it += Length; 323| 706| if constexpr (not Opts.null_terminated) { 324| 706| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 706] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 706| } 329| | 330| 706| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 706] ------------------ 331| 0| return; 332| 0| } 333| 706| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 31, False: 675] ------------------ 334| 31| return; 335| 31| } 336| 675| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 675] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 675| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 675| } 343| 25| else [[unlikely]] { 344| 25| decode_index_unknown_key(value, ctx, it, end); 345| 25| } 346| 731| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 675| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 675| else { 274| 675| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 675| else { 298| 675| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 675| it, end); 300| 675| } 301| 675| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 675| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 675| { 2792| 675| static constexpr auto num_members = reflect::size; 2793| | 2794| 675| static constexpr auto Opts = opening_handled_off()>(); 2795| 675| if constexpr (!check_opening_handled(Options)) { 2796| | if constexpr (!check_ws_handled(Options)) { 2797| | if (skip_ws(ctx, it, end)) { 2798| | return; 2799| | } 2800| | } 2801| 675| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 38, False: 637] ------------------ 2802| 38| return; 2803| 38| } 2804| 637| if constexpr (not Opts.null_terminated) { 2805| 637| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 637] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 637| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 637| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 637] ------------------ 2813| 0| return; 2814| 0| } 2815| 637| } 2816| 637| const auto ws_start = it; 2817| 675| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 675] ------------------ 2818| 0| return; 2819| 0| } 2820| 675| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 675| else { 2895| 675| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 675| if constexpr ((glaze_object_t || reflectable) && 2897| 675| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 675| return bit_array{}; 2899| 675| } 2900| 675| else { 2901| 675| return nullptr; 2902| 675| } 2903| 675| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 675| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 675| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 675| return has_includer_member; 2915| 675| } 2916| 675| else { 2917| 675| return false; 2918| 675| } 2919| 675| }(); 2920| 675| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 675| [[maybe_unused]] const std::conditional_t>, 2930| 675| inert_key_bits_scope> published_bits{ 2931| 675| ctx, [&]() -> void* { 2932| 675| if constexpr (tracks_include_keys) { 2933| 675| return &fields; 2934| 675| } 2935| 675| else { 2936| 675| return nullptr; 2937| 675| } 2938| 675| }()}; 2939| | 2940| 675| size_t read_count{}; // for partial_read 2941| | 2942| 675| bool first = true; 2943| 4.18k| while (true) { ------------------ | Branch (2943:20): [True: 3.59k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 3.59k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 77, False: 3.51k] ------------------ 2981| 77| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 77| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 77| } 3017| 77| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 77| if constexpr (not Opts.null_terminated) { 3019| 77| if (it == end) { ------------------ | Branch (3019:26): [True: 0, False: 77] ------------------ 3020| 0| ctx.error = error_code::end_reached; 3021| 0| return; 3022| 0| } 3023| 77| } 3024| 77| return; 3025| 77| } 3026| 3.51k| else if (first) { ------------------ | Branch (3026:25): [True: 579, False: 2.93k] ------------------ 3027| 579| first = false; 3028| 579| } 3029| 2.93k| else { 3030| 2.93k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 9, False: 2.92k] ------------------ 3031| 9| return; 3032| 9| } 3033| 2.92k| if constexpr (not Opts.null_terminated) { 3034| 2.92k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 2.92k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 2.92k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 2.92k| (!Opts.comments)) { 3042| 2.92k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 2.43k, False: 491] | Branch (3042:37): [True: 2.32k, False: 110] ------------------ 3043| 2.32k| skip_matching_ws(ws_start, it, ws_size); 3044| 2.32k| } 3045| 2.92k| } 3046| | 3047| 2.92k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 2.92k] ------------------ 3048| 0| return; 3049| 0| } 3050| 2.92k| } 3051| | 3052| 3.50k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 3.50k| else if constexpr (reflection_type) { 3118| 3.50k| static_assert(bool(hash_info.type)); 3119| | 3120| 3.50k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 445, False: 3.06k] ------------------ 3121| 445| ctx.error = error_code::expected_quote; 3122| 445| return; 3123| 445| } 3124| 3.06k| ++it; 3125| 3.06k| if constexpr (not Opts.null_terminated) { 3126| 3.06k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 3.06k] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 3.06k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 3.06k| else { 3181| 3.06k| parse_and_invoke(value, ctx, it, end); 3182| 3.06k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 106, False: 2.95k] ------------------ 3183| 106| return; 3184| 3.06k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 3.50k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 3.50k] ------------------ 3294| 0| return; 3295| 0| } 3296| 3.50k| } 3297| 675| } 3298| 675| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 637| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 637| else { 2901| 637| return nullptr; 2902| 637| } 2903| 637| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 637| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 637| else { 2936| 637| return nullptr; 2937| 637| } 2938| 637| }()}; _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 382| 16.5k| { 383| 16.5k| constexpr auto N = reflect::size; 384| | 385| | if constexpr (N == 1) { 386| | decode_index(value, ctx, it, end, selected_index...); 387| | } 388| | else if constexpr (check_linear_search(Opts)) { 389| | // Linear search path 390| | auto key_start = it; 391| | const auto index = decode_linear(ctx, it, end); 392| | if (bool(ctx.error)) [[unlikely]] 393| | return; 394| | 395| | if (index >= N) [[unlikely]] { 396| | if constexpr (Opts.error_on_unknown_keys) { 397| | ctx.error = error_code::unknown_key; 398| | return; 399| | } 400| | else { 401| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 402| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 403| | return; 404| | } 405| | const sv key{key_start, size_t(it - key_start - 1)}; 406| | if constexpr (not Opts.null_terminated) { 407| | if (it == end) [[unlikely]] { 408| | ctx.error = error_code::unexpected_end; 409| | return; 410| | } 411| | } 412| | if (parse_ws_colon(ctx, it, end)) { 413| | return; 414| | } 415| | parse::handle_unknown(key, value, ctx, it, end); 416| | return; 417| | } 418| | } 419| | 420| | if constexpr (not Opts.null_terminated) { 421| | if (it == end) [[unlikely]] { 422| | ctx.error = error_code::unexpected_end; 423| | return; 424| | } 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 430| | return; 431| | } 432| | if (skip_ws(ctx, it, end)) { 433| | return; 434| | } 435| | 436| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 437| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 438| | // instantiations; the whitespace before the value has already been skipped either way. 439| | [&](std::index_sequence) { 440| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 441| | : false) || 442| | ...)); 443| | }(std::make_index_sequence{}); 444| | } 445| 16.5k| else { 446| | // Hash-based lookup 447| 16.5k| constexpr auto& HashInfo = hash_info; 448| 16.5k| constexpr auto type = HashInfo.type; 449| 16.5k| static_assert(bool(type), "invalid hash algorithm"); 450| | 451| 16.5k| const auto index = decode_hash::op(it, end); 452| | 453| 16.5k| if (index >= N) [[unlikely]] { ------------------ | Branch (453:14): [True: 0, False: 16.5k] ------------------ 454| 0| if constexpr (Opts.error_on_unknown_keys) { 455| 0| ctx.error = error_code::unknown_key; 456| 0| return; 457| | } 458| | else { 459| | auto start = it; 460| | skip_string_view(ctx, it, end); 461| | if (bool(ctx.error)) [[unlikely]] 462| | return; 463| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 464| | return; 465| | const sv key = {start, size_t(it - start)}; 466| | ++it; // skip the quote 467| | if constexpr (not Opts.null_terminated) { 468| | if (it == end) [[unlikely]] { 469| | ctx.error = error_code::unexpected_end; 470| | return; 471| | } 472| | } 473| | if (parse_ws_colon(ctx, it, end)) { 474| | return; 475| | } 476| | parse::handle_unknown(key, value, ctx, it, end); 477| | return; 478| | } 479| 0| } 480| | 481| 16.5k| if constexpr (N == 2) { 482| 16.5k| if (index == 0) { ------------------ | Branch (482:17): [True: 15.6k, False: 853] ------------------ 483| 15.6k| decode_index(value, ctx, it, end, selected_index...); 484| 15.6k| } 485| 853| else { 486| 853| decode_index(value, ctx, it, end, selected_index...); 487| 853| } 488| | } 489| | else { 490| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 491| | } 492| 16.5k| } 493| 16.5k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 312| 15.6k| { 313| 15.6k| static constexpr auto Key = get(reflect::keys); 314| 15.6k| static constexpr auto KeyWithEndQuote = join_v>; 315| 15.6k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 15.6k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 15.6k, False: 13] | Branch (321:52): [True: 15.6k, False: 38] ------------------ 322| 15.6k| it += Length; 323| 15.6k| if constexpr (not Opts.null_terminated) { 324| 15.6k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 15.6k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 15.6k| } 329| | 330| 15.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 15.6k] ------------------ 331| 0| return; 332| 0| } 333| 15.6k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 34, False: 15.5k] ------------------ 334| 34| return; 335| 34| } 336| 15.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 15.5k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 15.5k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 15.5k| } 343| 51| else [[unlikely]] { 344| 51| decode_index_unknown_key(value, ctx, it, end); 345| 51| } 346| 15.6k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 15.5k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 15.5k| else { 274| 15.5k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 15.5k| else { 298| 15.5k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 15.5k| it, end); 300| 15.5k| } 301| 15.5k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 15.5k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 124| { 178| 124| if constexpr (Opts.error_on_unknown_keys) { 179| 124| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | uint64_t ascii_acc{}; 184| | skip_string_view(ctx, it, end, ascii_acc); 185| | if (bool(ctx.error)) [[unlikely]] 186| | return; 187| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 188| | return; 189| | const sv key = {start, size_t(it - start)}; 190| | ++it; 191| | if constexpr (not Opts.null_terminated) { 192| | if (it == end) [[unlikely]] { 193| | ctx.error = error_code::unexpected_end; 194| | return; 195| | } 196| | } 197| | 198| | if (parse_ws_colon(ctx, it, end)) { 199| | return; 200| | } 201| | 202| | parse::handle_unknown(key, value, ctx, it, end); 203| | } 204| 124| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 312| 853| { 313| 853| static constexpr auto Key = get(reflect::keys); 314| 853| static constexpr auto KeyWithEndQuote = join_v>; 315| 853| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 853| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 829, False: 24] | Branch (321:52): [True: 780, False: 49] ------------------ 322| 780| it += Length; 323| 780| if constexpr (not Opts.null_terminated) { 324| 780| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 780] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 780| } 329| | 330| 780| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 780] ------------------ 331| 0| return; 332| 0| } 333| 780| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 59, False: 721] ------------------ 334| 59| return; 335| 59| } 336| 721| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 721] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 721| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 721| } 343| 73| else [[unlikely]] { 344| 73| decode_index_unknown_key(value, ctx, it, end); 345| 73| } 346| 853| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 721| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 721| else { 274| 721| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 721| else { 298| 721| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 721| it, end); 300| 721| } 301| 721| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 721| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm4EEEDav: 490| 8.21k| 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_: 312| 8.21k| { 313| 8.21k| static constexpr auto Key = get(reflect::keys); 314| 8.21k| static constexpr auto KeyWithEndQuote = join_v>; 315| 8.21k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 8.21k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 8.20k, False: 9] | Branch (321:52): [True: 8.19k, False: 13] ------------------ 322| 8.19k| it += Length; 323| 8.19k| if constexpr (not Opts.null_terminated) { 324| 8.19k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 8.19k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 8.19k| } 329| | 330| 8.19k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 8.19k] ------------------ 331| 0| return; 332| 0| } 333| 8.19k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 33, False: 8.16k] ------------------ 334| 33| return; 335| 33| } 336| 8.16k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 8.16k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 8.16k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 8.16k| } 343| 22| else [[unlikely]] { 344| 22| decode_index_unknown_key(value, ctx, it, end); 345| 22| } 346| 8.21k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 8.16k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 8.16k| else { 274| 8.16k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 8.16k| else { 298| 8.16k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 8.16k| it, end); 300| 8.16k| } 301| 8.16k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 8.16k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2050| 8.16k| { 2051| 8.16k| constexpr auto Opts = ws_handled_off(); 2052| | if constexpr (!check_ws_handled(Options)) { 2053| | if (skip_ws(ctx, it, end)) { 2054| | return; 2055| | } 2056| | } 2057| | 2058| 8.16k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2058:14): [True: 34, False: 8.12k] ------------------ 2059| 34| return; 2060| 34| } 2061| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2062| | // released at each syntactic close below 2063| 8.12k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2063:14): [True: 0, False: 8.12k] ------------------ 2064| 0| return; 2065| 0| } 2066| | 2067| 8.12k| const auto ws_start = it; 2068| 8.12k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2068:14): [True: 0, False: 8.12k] ------------------ 2069| 0| return; 2070| 0| } 2071| | 2072| 8.12k| if (*it == ']') { ------------------ | Branch (2072:14): [True: 319, False: 7.80k] ------------------ 2073| 319| --ctx.depth; 2074| 319| ++it; 2075| 319| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2076| 319| value.clear(); 2077| | 2078| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2079| | value.shrink_to_fit(); 2080| | } 2081| 319| } 2082| 319| return; 2083| 319| } 2084| | 2085| 7.80k| const size_t ws_size = size_t(it - ws_start); 2086| | 2087| 7.80k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2087:49): [True: 7.80k, Folded] | Branch (2087:65): [Folded, False: 0] | Branch (2087:90): [Folded, False: 0] ------------------ 2088| 7.80k| if constexpr (not should_append) { 2089| 7.80k| const auto n = value.size(); 2090| | 2091| 7.80k| auto value_it = value.begin(); 2092| | 2093| 43.9k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2093:32): [True: 38.5k, False: 5.33k] ------------------ 2094| 38.5k| parse::op()>(*value_it++, ctx, it, end); 2095| 38.5k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2095:20): [True: 423, False: 38.1k] ------------------ 2096| 423| return; 2097| 38.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2097:20): [True: 0, False: 38.1k] ------------------ 2098| 0| return; 2099| 0| } 2100| 38.1k| if (*it == ',') { ------------------ | Branch (2100:20): [True: 36.1k, False: 2.04k] ------------------ 2101| 36.1k| ++it; 2102| | 2103| 36.1k| if constexpr (!Opts.minified && !Opts.comments) { 2104| 36.1k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2104:26): [True: 31.7k, False: 4.37k] | Branch (2104:37): [True: 31.4k, False: 299] ------------------ 2105| 31.4k| skip_matching_ws(ws_start, it, ws_size); 2106| 31.4k| } 2107| 36.1k| } 2108| | 2109| 36.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2109:23): [True: 0, False: 36.1k] ------------------ 2110| 0| return; 2111| 0| } 2112| 36.1k| } 2113| 2.04k| else if (*it == ']') { ------------------ | Branch (2113:25): [True: 1.62k, False: 421] ------------------ 2114| 1.62k| --ctx.depth; 2115| 1.62k| ++it; 2116| 1.62k| if constexpr (erasable) { 2117| 1.62k| value.erase(value_it, 2118| 1.62k| value.end()); // use erase rather than resize for non-default constructible elements 2119| | 2120| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2121| | value.shrink_to_fit(); 2122| | } 2123| 1.62k| } 2124| 1.62k| return; 2125| 1.62k| } 2126| 421| else [[unlikely]] { 2127| 421| ctx.error = error_code::expected_bracket; 2128| 421| return; 2129| 421| } 2130| 38.1k| } 2131| 7.80k| } 2132| | 2133| | if constexpr (Opts.partial_read) { 2134| | // partial_read stops early on a success path, so give the level back like the 2135| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2136| | --ctx.depth; 2137| | return; 2138| | } 2139| 7.80k| else { 2140| | // growing 2141| 7.80k| if constexpr (emplace_backable || has_try_emplace_back) { 2142| 105k| while (it < end) { ------------------ | Branch (2142:23): [True: 103k, False: 2.47k] ------------------ 2143| | // Streaming refill point: at start of each iteration, ensure buffer has data 2144| | if constexpr (has_streaming_state) { 2145| | if (ctx.stream.enabled()) { 2146| | const size_t consumed = static_cast(it - ctx.stream.data()); 2147| | const size_t remaining = ctx.stream.size() - consumed; 2148| | // Refill when less than half of buffer remains to ensure space for next element 2149| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2150| | const char* new_it; 2151| | const char* new_end; 2152| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2153| | it = new_it; 2154| | end = new_end; 2155| | if (it >= end && ctx.stream.at_eof()) { 2156| | break; // No more data, exit loop normally 2157| | } 2158| | } 2159| | } 2160| | } 2161| | 2162| | if constexpr (has_try_emplace_back) { 2163| | if (value.try_emplace_back()) 2164| | parse::op()>(value.back(), ctx, it, end); 2165| | else 2166| | ctx.error = error_code::exceeded_static_array_size; 2167| | } 2168| 103k| else { 2169| 103k| parse::op()>(value.emplace_back(), ctx, it, end); 2170| 103k| } 2171| | 2172| 103k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2172:23): [True: 1.32k, False: 101k] ------------------ 2173| 1.32k| return; 2174| | 2175| | // Streaming refill point: after parsing each element, refill if buffer is low 2176| | if constexpr (has_streaming_state) { 2177| | if (ctx.stream.enabled()) { 2178| | const size_t consumed = static_cast(it - ctx.stream.data()); 2179| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2180| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2181| | const char* new_it; 2182| | const char* new_end; 2183| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2184| | it = new_it; 2185| | end = new_end; 2186| | if (it >= end && ctx.stream.at_eof()) { 2187| | ctx.error = error_code::unexpected_end; 2188| | return; 2189| | } 2190| | } 2191| | } 2192| | } 2193| | 2194| 101k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2194:23): [True: 0, False: 101k] ------------------ 2195| 0| return; 2196| 0| } 2197| 101k| if (*it == ',') [[likely]] { ------------------ | Branch (2197:23): [True: 97.7k, False: 4.01k] ------------------ 2198| 97.7k| ++it; 2199| | 2200| 97.7k| if constexpr (!Opts.minified && !Opts.comments) { 2201| 97.7k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2201:29): [True: 85.5k, False: 12.2k] | Branch (2201:40): [True: 85.1k, False: 358] ------------------ 2202| 85.1k| skip_matching_ws(ws_start, it, ws_size); 2203| 85.1k| } 2204| 97.7k| } 2205| | 2206| 97.7k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2206:26): [True: 0, False: 97.7k] ------------------ 2207| 0| return; 2208| 0| } 2209| 97.7k| } 2210| 4.01k| else if (*it == ']') { ------------------ | Branch (2210:28): [True: 3.34k, False: 673] ------------------ 2211| 3.34k| --ctx.depth; 2212| 3.34k| ++it; 2213| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2214| | value.shrink_to_fit(); 2215| | } 2216| 3.34k| return; 2217| 3.34k| } 2218| 673| else [[unlikely]] { 2219| 673| ctx.error = error_code::expected_bracket; 2220| 673| return; 2221| 673| } 2222| 101k| } 2223| | 2224| | // A valid array always returns from inside the loop upon reaching ']'. 2225| | // For a null-terminated buffer the loop can only exit here by falling 2226| | // through when `it` reaches the terminator without a closing bracket, 2227| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2228| | // Non-null-terminated buffers surface this through skip_ws/depth 2229| | // tracking (or the streaming refill break), so this guard is limited 2230| | // to the null-terminated case. 2231| | if constexpr (Opts.null_terminated) { 2232| | ctx.error = error_code::unexpected_end; 2233| | } 2234| | } 2235| | else { 2236| | ctx.error = error_code::exceeded_static_array_size; 2237| | } 2238| 7.80k| } 2239| 7.80k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 415k| { 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| 415k| else { 60| 415k| using V = std::remove_cvref_t; 61| 415k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 415k| end); 63| 415k| } 64| 415k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm5EEEDav: 490| 1.22k| 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_: 312| 1.22k| { 313| 1.22k| static constexpr auto Key = get(reflect::keys); 314| 1.22k| static constexpr auto KeyWithEndQuote = join_v>; 315| 1.22k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 1.22k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 1.21k, False: 4] | Branch (321:52): [True: 1.21k, False: 5] ------------------ 322| 1.21k| it += Length; 323| 1.21k| if constexpr (not Opts.null_terminated) { 324| 1.21k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 1.21k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 1.21k| } 329| | 330| 1.21k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 1.21k] ------------------ 331| 0| return; 332| 0| } 333| 1.21k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 29, False: 1.18k] ------------------ 334| 29| return; 335| 29| } 336| 1.18k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 1.18k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 1.18k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 1.18k| } 343| 9| else [[unlikely]] { 344| 9| decode_index_unknown_key(value, ctx, it, end); 345| 9| } 346| 1.22k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 1.18k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 1.18k| else { 274| 1.18k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 1.18k| else { 298| 1.18k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 1.18k| it, end); 300| 1.18k| } 301| 1.18k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 1.18k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 2791| 1.18k| { 2792| 1.18k| static constexpr auto num_members = reflect::size; 2793| | 2794| 1.18k| static constexpr auto Opts = opening_handled_off()>(); 2795| 1.18k| if constexpr (!check_opening_handled(Options)) { 2796| | if constexpr (!check_ws_handled(Options)) { 2797| | if (skip_ws(ctx, it, end)) { 2798| | return; 2799| | } 2800| | } 2801| 1.18k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 39, False: 1.14k] ------------------ 2802| 39| return; 2803| 39| } 2804| 1.14k| if constexpr (not Opts.null_terminated) { 2805| 1.14k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 1.14k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 1.14k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 1.14k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 1.14k] ------------------ 2813| 0| return; 2814| 0| } 2815| 1.14k| } 2816| 1.14k| const auto ws_start = it; 2817| 1.18k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 1.18k] ------------------ 2818| 0| return; 2819| 0| } 2820| 1.18k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 1.18k| else { 2895| 1.18k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 1.18k| if constexpr ((glaze_object_t || reflectable) && 2897| 1.18k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 1.18k| return bit_array{}; 2899| 1.18k| } 2900| 1.18k| else { 2901| 1.18k| return nullptr; 2902| 1.18k| } 2903| 1.18k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 1.18k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 1.18k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 1.18k| return has_includer_member; 2915| 1.18k| } 2916| 1.18k| else { 2917| 1.18k| return false; 2918| 1.18k| } 2919| 1.18k| }(); 2920| 1.18k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 1.18k| [[maybe_unused]] const std::conditional_t>, 2930| 1.18k| inert_key_bits_scope> published_bits{ 2931| 1.18k| ctx, [&]() -> void* { 2932| 1.18k| if constexpr (tracks_include_keys) { 2933| 1.18k| return &fields; 2934| 1.18k| } 2935| 1.18k| else { 2936| 1.18k| return nullptr; 2937| 1.18k| } 2938| 1.18k| }()}; 2939| | 2940| 1.18k| size_t read_count{}; // for partial_read 2941| | 2942| 1.18k| bool first = true; 2943| 15.0k| while (true) { ------------------ | Branch (2943:20): [True: 14.3k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 14.3k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 428, False: 13.9k] ------------------ 2981| 428| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| | if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| | } 3017| 428| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 428| if constexpr (not Opts.null_terminated) { 3019| 428| if (it == end) { ------------------ | Branch (3019:26): [True: 0, False: 428] ------------------ 3020| 0| ctx.error = error_code::end_reached; 3021| 0| return; 3022| 0| } 3023| 428| } 3024| 428| return; 3025| 428| } 3026| 13.9k| else if (first) { ------------------ | Branch (3026:25): [True: 1.02k, False: 12.9k] ------------------ 3027| 1.02k| first = false; 3028| 1.02k| } 3029| 12.9k| else { 3030| 12.9k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 145, False: 12.7k] ------------------ 3031| 145| return; 3032| 145| } 3033| 12.7k| if constexpr (not Opts.null_terminated) { 3034| 12.7k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 12.7k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 12.7k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| | (!Opts.comments)) { 3042| | if (ws_size && ws_size < size_t(end - it)) { 3043| | skip_matching_ws(ws_start, it, ws_size); 3044| | } 3045| | } 3046| | 3047| 12.7k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 12.7k] ------------------ 3048| 0| return; 3049| 0| } 3050| 12.7k| } 3051| | 3052| 13.8k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [Folded, False: 0] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| | else if constexpr (reflection_type) { 3118| | static_assert(bool(hash_info.type)); 3119| | 3120| | if (*it != '"') [[unlikely]] { 3121| | ctx.error = error_code::expected_quote; 3122| | return; 3123| | } 3124| | ++it; 3125| | if constexpr (not Opts.null_terminated) { 3126| | if (it == end) [[unlikely]] { 3127| | ctx.error = error_code::unexpected_end; 3128| | return; 3129| | } 3130| | } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| | else { 3181| | parse_and_invoke(value, ctx, it, end); 3182| | if (bool(ctx.error)) [[unlikely]] 3183| | return; 3184| | } 3185| | } 3186| 13.8k| else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| 13.8k| auto reading = [&](auto&& key) { 3190| 13.8k| if constexpr (Opts.partial_read) { 3191| 13.8k| if (auto element = value.find(key); element != value.end()) { 3192| 13.8k| ++read_count; 3193| 13.8k| parse::op()>(element->second, ctx, it, end); 3194| 13.8k| } 3195| 13.8k| else { 3196| 13.8k| skip_value::op(ctx, it, end); 3197| 13.8k| } 3198| 13.8k| } 3199| 13.8k| else { 3200| 13.8k| parse::op()>(value[key], ctx, it, end); 3201| 13.8k| } 3202| 13.8k| }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| 13.8k| using Key = typename T::key_type; 3206| 13.8k| if constexpr (std::is_same_v) { 3207| 13.8k| ctx.scratch.clear(); 3208| 13.8k| parse::op(ctx.scratch, ctx, it, end); 3209| 13.8k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3209:26): [True: 120, False: 13.7k] ------------------ 3210| 120| return; 3211| | 3212| 13.7k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3212:26): [True: 83, False: 13.6k] ------------------ 3213| 83| return; 3214| 83| } 3215| | 3216| 13.6k| reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| 13.6k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3222:26): [True: 368, False: 13.2k] ------------------ 3223| 368| return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| 13.8k| } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 13.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 13.8k] ------------------ 3294| 0| return; 3295| 0| } 3296| 13.8k| } 3297| 1.18k| } 3298| 1.18k| } _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: 2895| 1.14k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 1.14k| else { 2901| 1.14k| return nullptr; 2902| 1.14k| } 2903| 1.14k| }(); _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 1.14k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 1.14k| else { 2936| 1.14k| return nullptr; 2937| 1.14k| } 2938| 1.14k| }()}; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 3.32M| { 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.32M| else { 60| 3.32M| using V = std::remove_cvref_t; 61| 3.32M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.32M| end); 63| 3.32M| } 64| 3.32M| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEEEvRT2_OT3_OT0_T1_: 887| 3.32M| { 888| | if constexpr (check_string_as_number(Opts)) { 889| | auto start = it; 890| | skip_number(ctx, it, end); 891| | if (bool(ctx.error)) [[unlikely]] { 892| | return; 893| | } 894| | if (start == it) [[unlikely]] { 895| | ctx.error = error_code::parse_number_failure; 896| | return; 897| | } 898| | value.append(start, size_t(it - start)); 899| | } 900| 3.32M| else { 901| 3.32M| if constexpr (!check_opening_handled(Opts)) { 902| 3.32M| if constexpr (!check_ws_handled(Opts)) { 903| 3.32M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (903:23): [True: 0, False: 3.32M] ------------------ 904| 0| return; 905| 0| } 906| 3.32M| } 907| | 908| 3.32M| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (908:20): [True: 563, False: 3.32M] ------------------ 909| 563| return; 910| 563| } 911| 3.32M| } 912| | 913| 3.32M| if constexpr (not check_raw_string(Opts)) { 914| 3.32M| static constexpr auto string_padding_bytes = 8; 915| | 916| | // How much buffer has to remain for an eight byte load at the cursor to stay inside 917| | // it. One on a padded input, where the last chunk is free to straddle the end of the 918| | // document, so the byte tails below are unreachable; eight otherwise, which costs the 919| | // final bytes of the buffer their chunked path and nothing else. 920| 3.32M| const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 921| | 922| 3.32M| if (size_t(end - it) >= 8) { ------------------ | Branch (922:20): [True: 3.30M, False: 19.9k] ------------------ 923| | // The bound as a pointer, so the loops below spend a compare per chunk rather 924| | // than a subtract and a compare. Well defined here and nowhere else in this 925| | // reader: the branch has just established that at least eight bytes remain, and 926| | // `scan_min` is at most eight. 927| 3.30M| const auto* const chunk_limit = end - scan_min; 928| | 929| 3.30M| auto start = it; 930| 3.30M| uint64_t ascii_acc{}; 931| 7.84M| while (it <= chunk_limit) { ------------------ | Branch (931:26): [True: 7.84M, False: 806] ------------------ 932| 7.84M| uint64_t chunk; 933| 7.84M| std::memcpy(&chunk, it, 8); 934| | if constexpr (std::endian::native == std::endian::big) { 935| | chunk = std::byteswap(chunk); 936| | } 937| 7.84M| ascii_acc |= chunk; 938| 7.84M| const uint64_t test_chars = has_quote(chunk); 939| 7.84M| if (test_chars) { ------------------ | Branch (939:26): [True: 3.31M, False: 4.52M] ------------------ 940| 3.31M| it += (countr_zero(test_chars) >> 3); 941| | 942| 3.31M| auto* prev = it - 1; 943| 3.36M| while (*prev == '\\') { ------------------ | Branch (943:32): [True: 44.9k, False: 3.31M] ------------------ 944| 44.9k| --prev; 945| 44.9k| } 946| 3.31M| if (size_t(it - prev) % 2) { ------------------ | Branch (946:29): [True: 3.30M, False: 9.30k] ------------------ 947| 3.30M| goto continue_decode; 948| 3.30M| } 949| 9.30k| ++it; // skip the escaped quote 950| 9.30k| } 951| 4.52M| else { 952| 4.52M| it += 8; 953| 4.52M| } 954| 7.84M| } 955| | 956| 2.54k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (956:26): [True: 1.74k, False: 806] ------------------ 957| | // if we ended on an escape character then we need to rewind 958| | // because we lost our context 959| 1.74k| --it; 960| 1.74k| } 961| | 962| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 963| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 964| 4.74k| for (; it < end; ++it) { ------------------ | Branch (964:26): [True: 4.74k, False: 0] ------------------ 965| 4.74k| ascii_acc |= uint8_t(*it); 966| 4.74k| if (*it == '"') { ------------------ | Branch (966:26): [True: 841, False: 3.90k] ------------------ 967| 841| auto* prev = it - 1; 968| 2.59k| while (*prev == '\\') { ------------------ | Branch (968:32): [True: 1.75k, False: 841] ------------------ 969| 1.75k| --prev; 970| 1.75k| } 971| 841| if (size_t(it - prev) % 2) { ------------------ | Branch (971:29): [True: 806, False: 35] ------------------ 972| 806| goto continue_decode; 973| 806| } 974| 841| } 975| 4.74k| } 976| | 977| 0| ctx.error = error_code::unexpected_end; 978| 0| return; 979| | 980| 3.30M| continue_decode: 981| | 982| 3.30M| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (982:23): [True: 0, False: 3.30M] ------------------ 983| 0| return; 984| 0| } 985| | 986| 3.30M| auto n = size_t(it - start); 987| | 988| | // The padding lets the chunked copy below run up to the closing quote. Skip it when it 989| | // would be the only reason to allocate, as for a string that fits the small string 990| | // buffer but not with eight bytes to spare. 991| 3.30M| bool pad = true; 992| 3.30M| if constexpr (requires { value.capacity(); }) { 993| 3.30M| const auto capacity = size_t(value.capacity()); 994| 3.30M| pad = capacity >= n + string_padding_bytes || capacity < n; ------------------ | Branch (994:28): [True: 3.30M, False: 1.36k] | Branch (994:68): [True: 545, False: 822] ------------------ 995| 3.30M| } 996| 3.30M| resize_unfilled(value, pad ? n + string_padding_bytes : n); ------------------ | Branch (996:42): [True: 3.30M, False: 822] ------------------ 997| | 998| 3.30M| auto* p = value.data(); 999| | 1000| | // An error below returns with the tail of `value` still unwritten. Leave the size at 1001| | // what was actually written rather than at the padded length, which resize_unfilled 1002| | // did not fill. 1003| 3.30M| auto* const written_begin = p; 1004| | 1005| | // Without the padding, copy a chunk only while eight bytes remain before the quote. 1006| | // Unescaping never puts the output ahead of the input, so no store lands past the end. 1007| 3.30M| const auto* const copy_end = pad ? it : it - (std::min)(n, size_t(7)); ------------------ | Branch (1007:48): [True: 3.30M, False: 822] ------------------ 1008| | 1009| | // Copy eight bytes at a time for as long as eight bytes are there to read, then 1010| | // finish the span below. The chunked form reads past the character it is looking 1011| | // at, so on an unpadded buffer it has to stop short of the end; splitting it this 1012| | // way keeps it for the body of every string rather than giving it up whenever the 1013| | // string happens to finish near the end of the buffer -- which, for a document 1014| | // that is itself one string, is every string. 1015| 10.1M| while (start < copy_end && start <= chunk_limit) { ------------------ | Branch (1015:26): [True: 6.86M, False: 3.30M] | Branch (1015:46): [True: 6.86M, False: 440] ------------------ 1016| 6.86M| std::memcpy(p, start, 8); 1017| 6.86M| uint64_t swar; 1018| 6.86M| std::memcpy(&swar, p, 8); 1019| | if constexpr (std::endian::native == std::endian::big) { 1020| | swar = std::byteswap(swar); 1021| | } 1022| | 1023| 6.86M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1024| 6.86M| const uint64_t lo7 = swar & lo7_mask; 1025| 6.86M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1026| 6.86M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1027| 6.86M| uint64_t next = ~((backslash & less_32) | swar); 1028| | 1029| 6.86M| next &= repeat_byte8(0b10000000); 1030| 6.86M| if (next == 0) { ------------------ | Branch (1030:26): [True: 6.77M, False: 89.8k] ------------------ 1031| 6.77M| start += 8; 1032| 6.77M| p += 8; 1033| 6.77M| continue; 1034| 6.77M| } 1035| | 1036| 89.8k| next = countr_zero(next) >> 3; 1037| 89.8k| start += next; 1038| 89.8k| if (start >= it) { ------------------ | Branch (1038:26): [True: 3.12k, False: 86.7k] ------------------ 1039| 3.12k| break; 1040| 3.12k| } 1041| | 1042| 86.7k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1042:26): [True: 184, False: 86.5k] ------------------ 1043| 184| ctx.error = error_code::syntax_error; 1044| 184| value.resize(size_t(p - written_begin)); 1045| 184| return; 1046| 184| } 1047| 86.5k| ++start; // skip the escape 1048| 86.5k| if (*start == 'u') { ------------------ | Branch (1048:26): [True: 64.6k, False: 21.9k] ------------------ 1049| 64.6k| ++start; 1050| 64.6k| p += next; 1051| 64.6k| const auto mark = start; 1052| 64.6k| const auto decoded = handle_unicode_code_point(start, p, end); 1053| 64.6k| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1053:29): [True: 163, False: 64.5k] ------------------ 1054| 163| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1054:40): [True: 0, False: 163] ------------------ 1055| 163| : error_code::unicode_escape_conversion_failure; 1056| 163| value.resize(size_t(p - written_begin)); 1057| 163| return; 1058| 163| } 1059| 64.5k| n += decoded.written; 1060| | // escape + u + unicode code points 1061| 64.5k| n -= 2 + uint32_t(start - mark); 1062| 64.5k| } 1063| 21.9k| else { 1064| 21.9k| p += next; 1065| 21.9k| *p = char_unescape_table[uint8_t(*start)]; 1066| 21.9k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1066:29): [True: 47, False: 21.8k] ------------------ 1067| 47| ctx.error = error_code::invalid_escape; 1068| 47| value.resize(size_t(p - written_begin)); 1069| 47| return; 1070| 47| } 1071| 21.8k| ++p; 1072| 21.8k| ++start; 1073| 21.8k| --n; 1074| 21.8k| } 1075| 86.5k| } 1076| | 1077| | // Whatever the chunked copy could not reach. `p` and `start` stay in step across 1078| | // that loop, so this picks up exactly where it stopped. 1079| 3.31M| while (start < it) { ------------------ | Branch (1079:26): [True: 4.44k, False: 3.30M] ------------------ 1080| 4.44k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1080:26): [True: 31, False: 4.41k] ------------------ 1081| 31| ctx.error = error_code::syntax_error; 1082| 31| value.resize(size_t(p - written_begin)); 1083| 31| return; 1084| 31| } 1085| 4.41k| if (*start == '\\') { ------------------ | Branch (1085:26): [True: 482, False: 3.93k] ------------------ 1086| 482| ++start; // skip the escape 1087| 482| if (*start == 'u') { ------------------ | Branch (1087:29): [True: 87, False: 395] ------------------ 1088| 87| ++start; 1089| 87| const auto mark = start; 1090| 87| const auto decoded = handle_unicode_code_point(start, p, end); 1091| 87| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1091:32): [True: 40, False: 47] ------------------ 1092| 40| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1092:43): [True: 0, False: 40] ------------------ 1093| 40| : error_code::unicode_escape_conversion_failure; 1094| 40| value.resize(size_t(p - written_begin)); 1095| 40| return; 1096| 40| } 1097| 47| n += decoded.written; 1098| 47| n -= 2 + uint32_t(start - mark); 1099| 47| } 1100| 395| else { 1101| 395| *p = char_unescape_table[uint8_t(*start)]; 1102| 395| if (*p == 0) [[unlikely]] { ------------------ | Branch (1102:32): [True: 9, False: 386] ------------------ 1103| 9| ctx.error = error_code::invalid_escape; 1104| 9| value.resize(size_t(p - written_begin)); 1105| 9| return; 1106| 9| } 1107| 386| ++p; 1108| 386| ++start; 1109| 386| --n; 1110| 386| } 1111| 482| } 1112| 3.93k| else { 1113| 3.93k| *p = *start; 1114| 3.93k| ++p; 1115| 3.93k| ++start; 1116| 3.93k| } 1117| 4.41k| } 1118| | 1119| 3.30M| value.resize(n); 1120| 3.30M| ++it; 1121| 3.30M| } 1122| 19.9k| else { 1123| | // For short strings 1124| | 1125| 19.9k| std::array buffer{}; 1126| | 1127| 19.9k| auto* p = buffer.data(); 1128| 19.9k| const auto* const utf8_start = it; 1129| | 1130| 57.4k| while (it < end) [[likely]] { ------------------ | Branch (1130:26): [True: 56.9k, False: 563] ------------------ 1131| 56.9k| *p = *it; 1132| 56.9k| if (*it == '"') { ------------------ | Branch (1132:26): [True: 19.2k, False: 37.6k] ------------------ 1133| 19.2k| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1133:29): [True: 0, False: 19.2k] ------------------ 1134| 0| return; 1135| 0| } 1136| 19.2k| const size_t n = size_t(p - buffer.data()); 1137| 19.2k|#if __has_cpp_attribute(assume) >= 202207L 1138| 19.2k| [[assume(n <= sizeof(buffer))]]; 1139| 19.2k|#endif 1140| 19.2k| value.assign(buffer.data(), n); 1141| 19.2k| ++it; 1142| 19.2k| if constexpr (not Opts.null_terminated) { 1143| 19.2k| if (it == end) { ------------------ | Branch (1143:32): [True: 213, False: 19.0k] ------------------ 1144| 213| ctx.error = error_code::end_reached; 1145| 213| return; 1146| 213| } 1147| 19.2k| } 1148| 19.0k| return; 1149| 19.2k| } 1150| 37.6k| else if (*it == '\\') { ------------------ | Branch (1150:31): [True: 170, False: 37.4k] ------------------ 1151| | // Bounded whatever `null_terminated` says: a document cut off inside an 1152| | // escape has run out of input, and saying so beats blaming the terminator 1153| | // the cut exposed -- which is what reading on would find, and would report 1154| | // as a malformed escape. 1155| 170| ++it; // skip the escape 1156| 170| if (it == end) [[unlikely]] { ------------------ | Branch (1156:29): [True: 0, False: 170] ------------------ 1157| 0| ctx.error = error_code::unexpected_end; 1158| 0| return; 1159| 0| } 1160| 170| if (*it == 'u') { ------------------ | Branch (1160:29): [True: 109, False: 61] ------------------ 1161| 109| ++it; 1162| 109| if (it == end) [[unlikely]] { ------------------ | Branch (1162:32): [True: 0, False: 109] ------------------ 1163| 0| ctx.error = error_code::unexpected_end; 1164| 0| return; 1165| 0| } 1166| 109| const auto decoded = handle_unicode_code_point(it, p, end); 1167| 109| if (decoded.written == 0) [[unlikely]] { ------------------ | Branch (1167:32): [True: 42, False: 67] ------------------ 1168| 42| ctx.error = decoded.truncated ? error_code::unexpected_end ------------------ | Branch (1168:43): [True: 0, False: 42] ------------------ 1169| 42| : error_code::unicode_escape_conversion_failure; 1170| 42| return; 1171| 42| } 1172| 109| } 1173| 61| else { 1174| 61| *p = char_unescape_table[uint8_t(*it)]; 1175| 61| if (*p == 0) [[unlikely]] { ------------------ | Branch (1175:32): [True: 11, False: 50] ------------------ 1176| 11| ctx.error = error_code::invalid_escape; 1177| 11| return; 1178| 11| } 1179| 50| ++p; 1180| 50| ++it; 1181| 50| } 1182| 170| } 1183| 37.4k| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1183:31): [True: 23, False: 37.4k] ------------------ 1184| 23| ctx.error = error_code::syntax_error; 1185| 23| return; 1186| 23| } 1187| 37.4k| else { 1188| 37.4k| ++it; 1189| 37.4k| ++p; 1190| 37.4k| } 1191| 56.9k| } 1192| | 1193| 563| ctx.error = error_code::unexpected_end; 1194| 563| } 1195| | } 1196| | else { 1197| | // raw_string 1198| | auto start = it; 1199| | skip_string_view(ctx, it, end); 1200| | if (bool(ctx.error)) [[unlikely]] 1201| | return; 1202| | 1203| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1204| | return; 1205| | } 1206| | 1207| | value.assign(start, size_t(it - start)); 1208| | ++it; 1209| | } 1210| 3.32M| } 1211| 3.32M| } _ZN3glz14parse_ws_colonITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT0_OT1_T2_: 159| 3.32M| { 160| 3.32M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (160:11): [True: 0, False: 3.32M] ------------------ 161| 0| return true; 162| 0| } 163| 3.32M| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (163:11): [True: 249, False: 3.32M] ------------------ 164| 249| return true; 165| 249| } 166| 3.32M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (166:11): [True: 0, False: 3.32M] ------------------ 167| 0| return true; 168| 0| } 169| 3.32M| return false; 170| 3.32M| } _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_: 3189| 13.6k| auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| 13.6k| else { 3200| 13.6k| parse::op()>(value[key], ctx, it, end); 3201| 13.6k| } 3202| 13.6k| }; _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm6EEEDav: 490| 1.41k| 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_: 312| 1.41k| { 313| 1.41k| static constexpr auto Key = get(reflect::keys); 314| 1.41k| static constexpr auto KeyWithEndQuote = join_v>; 315| 1.41k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 1.41k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 1.41k, False: 7] | Branch (321:52): [True: 1.40k, False: 4] ------------------ 322| 1.40k| it += Length; 323| 1.40k| if constexpr (not Opts.null_terminated) { 324| 1.40k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 1.40k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 1.40k| } 329| | 330| 1.40k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 1.40k] ------------------ 331| 0| return; 332| 0| } 333| 1.40k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 25, False: 1.38k] ------------------ 334| 25| return; 335| 25| } 336| 1.38k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 1.38k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 1.38k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 1.38k| } 343| 11| else [[unlikely]] { 344| 11| decode_index_unknown_key(value, ctx, it, end); 345| 11| } 346| 1.41k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 1.38k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 1.38k| else { 274| 1.38k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 1.38k| else { 298| 1.38k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 1.38k| it, end); 300| 1.38k| } 301| 1.38k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 1.38k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 4883| 1.38k| { 4884| 1.38k| constexpr auto Opts = ws_handled_off(); 4885| | if constexpr (!check_ws_handled(Options)) { 4886| | if (skip_ws(ctx, it, end)) { 4887| | return; 4888| | } 4889| | } 4890| | 4891| 1.38k| if (*it == 'n') { ------------------ | Branch (4891:14): [True: 569, False: 813] ------------------ 4892| 569| ++it; 4893| 569| if constexpr (not Opts.null_terminated) { 4894| 569| if (it == end) [[unlikely]] { ------------------ | Branch (4894:20): [True: 0, False: 569] ------------------ 4895| 0| ctx.error = error_code::unexpected_end; 4896| 0| return; 4897| 0| } 4898| 569| } 4899| 569| match<"ull", Opts>(ctx, it, end); 4900| 569| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (4900:17): [True: 43, False: 526] ------------------ 4901| 43| return; 4902| 526| if constexpr (requires { value.reset(); }) { 4903| 526| value.reset(); 4904| 526| } 4905| 526| } 4906| 813| else { 4907| 813| if constexpr (nullable_value_t) { 4908| 813| if (not value.has_value()) { ------------------ | Branch (4908:20): [True: 411, False: 402] ------------------ 4909| | if constexpr (constructible) { 4910| | value = meta_construct_v(); 4911| | } 4912| 411| else if constexpr (requires { value.emplace(); }) { 4913| 411| value.emplace(); 4914| | } 4915| | else { 4916| | static_assert(false_v, 4917| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 4918| | "create a custom glz::from specialization"); 4919| | } 4920| 411| } 4921| 813| parse::op(value.value(), ctx, it, end); 4922| | } 4923| | else { 4924| | if (!value) { 4925| | if (!nullable_emplace(value, ctx)) { 4926| | return; 4927| | } 4928| | } 4929| | parse::op(*value, ctx, it, end); 4930| | } 4931| 813| } 4932| 1.38k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 3.70k| { 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.70k| else { 60| 3.70k| using V = std::remove_cvref_t; 61| 3.70k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.70k| end); 63| 3.70k| } 64| 3.70k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 763| 3.70k| { 764| | if constexpr (check_quoted_num(Opts)) { 765| | if (skip_ws(ctx, it, end)) { 766| | return; 767| | } 768| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 769| | return; 770| | } 771| | } 772| | 773| 3.70k| if constexpr (!check_ws_handled(Opts)) { 774| 3.70k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (774:17): [True: 0, False: 3.70k] ------------------ 775| 0| return; 776| 0| } 777| 3.70k| } 778| | 779| 3.70k| using V = std::decay_t; 780| | if constexpr (int_t) { 781| | static_assert(sizeof(*it) == sizeof(char)); 782| | 783| | if constexpr (Opts.null_terminated) { 784| | if (not glz::atoi(value, it)) [[unlikely]] { 785| | ctx.error = error_code::parse_number_failure; 786| | return; 787| | } 788| | } 789| | else { 790| | if (not glz::atoi(value, it, end)) [[unlikely]] { 791| | ctx.error = error_code::parse_number_failure; 792| | return; 793| | } 794| | } 795| | } 796| 3.70k| else { 797| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 798| 3.70k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 799| | if constexpr (is_float128) { 800| | auto [ptr, ec] = std::from_chars(it, end, value); 801| | if (ec != std::errc()) { 802| | ctx.error = error_code::parse_number_failure; 803| | return; 804| | } 805| | it = ptr; 806| | } 807| | else 808| |#endif 809| 3.70k| { 810| | if constexpr (std::is_volatile_v>) { 811| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 812| | // place 813| | V temp; 814| | if constexpr (is_size_optimized(Opts)) { 815| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 816| | if (ec != std::errc{}) [[unlikely]] { 817| | ctx.error = error_code::parse_number_failure; 818| | return; 819| | } 820| | it = ptr; 821| | } 822| | else { 823| | auto [ptr, ec] = glz::from_chars(it, end, temp); 824| | if (ec != std::errc()) [[unlikely]] { 825| | ctx.error = error_code::parse_number_failure; 826| | return; 827| | } 828| | it = ptr; 829| | } 830| | value = temp; 831| | } 832| 3.70k| else { 833| | if constexpr (is_size_optimized(Opts)) { 834| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 835| | if (ec != std::errc{}) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | it = ptr; 840| | } 841| 3.70k| else { 842| 3.70k| auto [ptr, ec] = glz::from_chars(it, end, value); 843| 3.70k| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (843:26): [True: 678, False: 3.02k] ------------------ 844| 678| ctx.error = error_code::parse_number_failure; 845| 678| return; 846| 678| } 847| 3.02k| it = ptr; 848| 3.02k| } 849| 3.70k| } 850| 3.70k| } 851| 3.70k| } 852| | 853| | if constexpr (check_quoted_num(Opts)) { 854| | if constexpr (not Opts.null_terminated) { 855| | if (it == end) [[unlikely]] { 856| | ctx.error = error_code::unexpected_end; 857| | return; 858| | } 859| | } 860| | if (match<'"'>(ctx, it)) { 861| | return; 862| | } 863| | if constexpr (not Opts.null_terminated) { 864| | if (it == end) { 865| | ctx.error = error_code::end_reached; 866| | return; 867| | } 868| | } 869| | } 870| 3.70k| else { 871| 3.70k| if constexpr (not Opts.null_terminated) { 872| 3.70k| if (it == end) { ------------------ | Branch (872:20): [True: 2.05k, False: 1.64k] ------------------ 873| 2.05k| ctx.error = error_code::end_reached; 874| 2.05k| return; 875| 2.05k| } 876| 3.70k| } 877| 3.70k| } 878| 3.70k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm7EEEDav: 490| 1.54k| 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_: 312| 1.54k| { 313| 1.54k| static constexpr auto Key = get(reflect::keys); 314| 1.54k| static constexpr auto KeyWithEndQuote = join_v>; 315| 1.54k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 1.54k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 1.53k, False: 9] | Branch (321:52): [True: 1.37k, False: 161] ------------------ 322| 1.37k| it += Length; 323| 1.37k| if constexpr (not Opts.null_terminated) { 324| 1.37k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 1.37k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 1.37k| } 329| | 330| 1.37k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 1.37k] ------------------ 331| 0| return; 332| 0| } 333| 1.37k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 26, False: 1.35k] ------------------ 334| 26| return; 335| 26| } 336| 1.35k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 1.35k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 1.35k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 1.35k| } 343| 170| else [[unlikely]] { 344| 170| decode_index_unknown_key(value, ctx, it, end); 345| 170| } 346| 1.54k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 1.35k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 1.35k| else { 274| 1.35k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 1.35k| else { 298| 1.35k| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 1.35k| it, end); 300| 1.35k| } 301| 1.35k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 1.35k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 3860| 1.35k| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 1.35k| else { 3865| 1.35k| read_deduced(value, ctx, it, end); 3866| 1.35k| } 3867| 1.35k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 3871| 1.35k| { 3872| 1.35k| constexpr auto Opts = ws_handled_off(); 3873| 1.35k| if constexpr (variant_is_auto_deducible()) { 3874| | if constexpr (not check_ws_handled(Options)) { 3875| | if (skip_ws(ctx, it, end)) { 3876| | return; 3877| | } 3878| | } 3879| | 3880| 1.35k| switch (*it) { 3881| 3| case '\0': ------------------ | Branch (3881:13): [True: 3, False: 1.34k] ------------------ 3882| 3| ctx.error = error_code::unexpected_end; 3883| 3| return; 3884| 266| case '{': { ------------------ | Branch (3884:13): [True: 266, False: 1.08k] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 266| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 266] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 266| ++it; 3894| 266| if constexpr (not Opts.null_terminated) { 3895| 266| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 0, False: 266] ------------------ 3896| 0| ctx.error = error_code::unexpected_end; 3897| 0| return; 3898| 0| } 3899| 266| } 3900| 266| using type_counts = variant_type_count; 3901| 266| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| | if constexpr (n_object_candidates < 1) { 3903| | ctx.error = error_code::no_matching_variant_type; 3904| | return; 3905| | } 3906| 266| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| 266| constexpr auto first_idx = variant_first_object_candidate_v; 3908| 266| using V = std::variant_alternative_t; 3909| 266| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (3909:23): [True: 104, False: 162] ------------------ 3910| 266| parse::op()>(std::get(value), ctx, it, end); 3911| 266| return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 266| } 4596| 3| case '[': ------------------ | Branch (4596:13): [True: 3, False: 1.34k] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 3| process_variant_alternatives::template op(value, ctx, it, end); 4599| 3| break; 4600| 1.04k| case '"': { ------------------ | Branch (4600:13): [True: 1.04k, False: 305] ------------------ 4601| 1.04k| process_variant_alternatives::template op(value, ctx, it, end); 4602| 1.04k| break; 4603| 266| } 4604| 3| case 't': ------------------ | Branch (4604:13): [True: 3, False: 1.34k] ------------------ 4605| 6| case 'f': { ------------------ | Branch (4605:13): [True: 3, False: 1.34k] ------------------ 4606| 6| process_variant_alternatives::template op(value, ctx, it, end); 4607| 6| break; 4608| 3| } 4609| 5| case 'n': ------------------ | Branch (4609:13): [True: 5, False: 1.34k] ------------------ 4610| 5| if constexpr (variant_count_v == 0) { 4611| 5| ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| | else { 4614| | constexpr auto first_idx = variant_first_index_v; 4615| | using V = std::variant_alternative_t; 4616| | if (!std::holds_alternative(value)) value = V{}; 4617| | match<"null", Opts>(ctx, it, end); 4618| | } 4619| 5| break; 4620| 22| default: { ------------------ | Branch (4620:13): [True: 22, False: 1.32k] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 22| process_variant_alternatives::template op(value, ctx, it, end); 4623| 22| } 4624| 1.35k| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 1.35k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERN12jsonrpc_fuzz6amountETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 529| { 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| 529| else { 60| 529| using V = std::remove_cvref_t; 61| 529| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 529| end); 63| 529| } 64| 529| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 529| { 2792| 529| static constexpr auto num_members = reflect::size; 2793| | 2794| 529| static constexpr auto Opts = opening_handled_off()>(); 2795| | if constexpr (!check_opening_handled(Options)) { 2796| | if constexpr (!check_ws_handled(Options)) { 2797| | if (skip_ws(ctx, it, end)) { 2798| | return; 2799| | } 2800| | } 2801| | if (match_invalid_end<'{', Opts>(ctx, it, end)) { 2802| | return; 2803| | } 2804| | if constexpr (not Opts.null_terminated) { 2805| | if (it == end) [[unlikely]] { 2806| | ctx.error = error_code::unexpected_end; 2807| | return; 2808| | } 2809| | } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| | if (enter_depth(ctx)) [[unlikely]] { 2813| | return; 2814| | } 2815| | } 2816| 529| const auto ws_start = it; 2817| 529| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 529] ------------------ 2818| 0| return; 2819| 0| } 2820| 529| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 529| else { 2895| 529| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 529| if constexpr ((glaze_object_t || reflectable) && 2897| 529| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 529| return bit_array{}; 2899| 529| } 2900| 529| else { 2901| 529| return nullptr; 2902| 529| } 2903| 529| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 529| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 529| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 529| return has_includer_member; 2915| 529| } 2916| 529| else { 2917| 529| return false; 2918| 529| } 2919| 529| }(); 2920| 529| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 529| [[maybe_unused]] const std::conditional_t>, 2930| 529| inert_key_bits_scope> published_bits{ 2931| 529| ctx, [&]() -> void* { 2932| 529| if constexpr (tracks_include_keys) { 2933| 529| return &fields; 2934| 529| } 2935| 529| else { 2936| 529| return nullptr; 2937| 529| } 2938| 529| }()}; 2939| | 2940| 529| size_t read_count{}; // for partial_read 2941| | 2942| 529| bool first = true; 2943| 1.02k| while (true) { ------------------ | Branch (2943:20): [True: 826, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 826| if (*it == '}') { ------------------ | Branch (2980:20): [True: 313, False: 513] ------------------ 2981| 313| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 313| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 313| } 3017| 313| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 313| if constexpr (not Opts.null_terminated) { 3019| 313| if (it == end) { ------------------ | Branch (3019:26): [True: 53, False: 260] ------------------ 3020| 53| ctx.error = error_code::end_reached; 3021| 53| return; 3022| 53| } 3023| 313| } 3024| 260| return; 3025| 313| } 3026| 513| else if (first) { ------------------ | Branch (3026:25): [True: 245, False: 268] ------------------ 3027| 245| first = false; 3028| 245| } 3029| 268| else { 3030| 268| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 14, False: 254] ------------------ 3031| 14| return; 3032| 14| } 3033| 254| if constexpr (not Opts.null_terminated) { 3034| 254| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 254] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 254| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| | (!Opts.comments)) { 3042| | if (ws_size && ws_size < size_t(end - it)) { 3043| | skip_matching_ws(ws_start, it, ws_size); 3044| | } 3045| | } 3046| | 3047| 254| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 254] ------------------ 3048| 0| return; 3049| 0| } 3050| 254| } 3051| | 3052| 499| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 499| else if constexpr (reflection_type) { 3118| 499| static_assert(bool(hash_info.type)); 3119| | 3120| 499| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 56, False: 443] ------------------ 3121| 56| ctx.error = error_code::expected_quote; 3122| 56| return; 3123| 56| } 3124| 443| ++it; 3125| 443| if constexpr (not Opts.null_terminated) { 3126| 443| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 443] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 443| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 443| else { 3181| 443| parse_and_invoke(value, ctx, it, end); 3182| 443| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 146, False: 297] ------------------ 3183| 146| return; 3184| 443| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 499| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 499] ------------------ 3294| 0| return; 3295| 0| } 3296| 499| } 3297| 529| } 3298| 529| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 529| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 529| else { 2901| 529| return nullptr; 2902| 529| } 2903| 529| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 529| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 529| else { 2936| 529| return nullptr; 2937| 529| } 2938| 529| }()}; _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 382| 443| { 383| 443| constexpr auto N = reflect::size; 384| | 385| 443| if constexpr (N == 1) { 386| 443| decode_index(value, ctx, it, end, selected_index...); 387| | } 388| | else if constexpr (check_linear_search(Opts)) { 389| | // Linear search path 390| | auto key_start = it; 391| | const auto index = decode_linear(ctx, it, end); 392| | if (bool(ctx.error)) [[unlikely]] 393| | return; 394| | 395| | if (index >= N) [[unlikely]] { 396| | if constexpr (Opts.error_on_unknown_keys) { 397| | ctx.error = error_code::unknown_key; 398| | return; 399| | } 400| | else { 401| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 402| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 403| | return; 404| | } 405| | const sv key{key_start, size_t(it - key_start - 1)}; 406| | if constexpr (not Opts.null_terminated) { 407| | if (it == end) [[unlikely]] { 408| | ctx.error = error_code::unexpected_end; 409| | return; 410| | } 411| | } 412| | if (parse_ws_colon(ctx, it, end)) { 413| | return; 414| | } 415| | parse::handle_unknown(key, value, ctx, it, end); 416| | return; 417| | } 418| | } 419| | 420| | if constexpr (not Opts.null_terminated) { 421| | if (it == end) [[unlikely]] { 422| | ctx.error = error_code::unexpected_end; 423| | return; 424| | } 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 430| | return; 431| | } 432| | if (skip_ws(ctx, it, end)) { 433| | return; 434| | } 435| | 436| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 437| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 438| | // instantiations; the whitespace before the value has already been skipped either way. 439| | [&](std::index_sequence) { 440| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 441| | : false) || 442| | ...)); 443| | }(std::make_index_sequence{}); 444| | } 445| | else { 446| | // Hash-based lookup 447| | constexpr auto& HashInfo = hash_info; 448| | constexpr auto type = HashInfo.type; 449| | static_assert(bool(type), "invalid hash algorithm"); 450| | 451| | const auto index = decode_hash::op(it, end); 452| | 453| | if (index >= N) [[unlikely]] { 454| | if constexpr (Opts.error_on_unknown_keys) { 455| | ctx.error = error_code::unknown_key; 456| | return; 457| | } 458| | else { 459| | auto start = it; 460| | skip_string_view(ctx, it, end); 461| | if (bool(ctx.error)) [[unlikely]] 462| | return; 463| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 464| | return; 465| | const sv key = {start, size_t(it - start)}; 466| | ++it; // skip the quote 467| | if constexpr (not Opts.null_terminated) { 468| | if (it == end) [[unlikely]] { 469| | ctx.error = error_code::unexpected_end; 470| | return; 471| | } 472| | } 473| | if (parse_ws_colon(ctx, it, end)) { 474| | return; 475| | } 476| | parse::handle_unknown(key, value, ctx, it, end); 477| | return; 478| | } 479| | } 480| | 481| | if constexpr (N == 2) { 482| | if (index == 0) { 483| | decode_index(value, ctx, it, end, selected_index...); 484| | } 485| | else { 486| | decode_index(value, ctx, it, end, selected_index...); 487| | } 488| | } 489| | else { 490| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 491| | } 492| | } 493| 443| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 312| 443| { 313| 443| static constexpr auto Key = get(reflect::keys); 314| 443| static constexpr auto KeyWithEndQuote = join_v>; 315| 443| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 443| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 431, False: 12] | Branch (321:52): [True: 360, False: 71] ------------------ 322| 360| it += Length; 323| 360| if constexpr (not Opts.null_terminated) { 324| 360| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 360] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 360| } 329| | 330| 360| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 360] ------------------ 331| 0| return; 332| 0| } 333| 360| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 31, False: 329] ------------------ 334| 31| return; 335| 31| } 336| 329| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 329] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 329| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 329| } 343| 83| else [[unlikely]] { 344| 83| decode_index_unknown_key(value, ctx, it, end); 345| 83| } 346| 443| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 329| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 329| else { 274| 329| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 329| else { 298| 329| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 329| it, end); 300| 329| } 301| 329| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 329| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 83| { 178| 83| if constexpr (Opts.error_on_unknown_keys) { 179| 83| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | uint64_t ascii_acc{}; 184| | skip_string_view(ctx, it, end, ascii_acc); 185| | if (bool(ctx.error)) [[unlikely]] 186| | return; 187| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 188| | return; 189| | const sv key = {start, size_t(it - start)}; 190| | ++it; 191| | if constexpr (not Opts.null_terminated) { 192| | if (it == end) [[unlikely]] { 193| | ctx.error = error_code::unexpected_end; 194| | return; 195| | } 196| | } 197| | 198| | if (parse_ws_colon(ctx, it, end)) { 199| | return; 200| | } 201| | 202| | parse::handle_unknown(key, value, ctx, it, end); 203| | } 204| 83| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3520| 26| { 3521| 26| constexpr auto category_count = variant_count_v; 3522| | 3523| 26| if constexpr (category_count == 0) { 3524| 26| ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| | else { 3527| | constexpr auto N = std::variant_size_v; 3528| | constexpr auto const_count = variant_filtered_count_v; 3529| | constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| | bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| | bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| | if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| | size_t non_const_idx = 0; 3588| | 3589| | for_each([&]() { 3590| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| | return; 3592| | } 3593| | using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| | }); 3645| | if (!found_match) { 3646| | if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| | } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| | } 3659| 26| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3520| 1.80k| { 3521| 1.80k| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 1.80k| else { 3527| 1.80k| constexpr auto N = std::variant_size_v; 3528| 1.80k| constexpr auto const_count = variant_filtered_count_v; 3529| 1.80k| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 1.80k| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 1.80k| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 1.80k| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 1.80k| size_t non_const_idx = 0; 3588| | 3589| 1.80k| for_each([&]() { 3590| 1.80k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 1.80k| return; 3592| 1.80k| } 3593| 1.80k| using V = std::variant_alternative_t; 3594| 1.80k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 1.80k| auto copy_it{it}; 3596| 1.80k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 1.80k| if (!std::holds_alternative(value)) { 3598| 1.80k| value = V{}; 3599| 1.80k| } 3600| 1.80k| parse::op()>(std::get(value), ctx, it, end); 3601| 1.80k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 1.80k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 1.80k| } 3604| 1.80k| if (!bool(ctx.error)) { 3605| 1.80k| found_match = true; 3606| 1.80k| } 3607| 1.80k| else if constexpr (not Options.null_terminated) { 3608| 1.80k| constexpr bool is_complete_type = 3609| 1.80k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 1.80k| if constexpr (is_complete_type) { 3612| 1.80k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 1.80k| found_match = true; 3614| 1.80k| ctx.error = error_code::none; 3615| 1.80k| } 3616| 1.80k| else { 3617| 1.80k| it = copy_it; 3618| 1.80k| rewind_depth(ctx, copy_depth); 3619| 1.80k| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 1.80k| not variant_alternative_exhausted(ctx)) { 3621| 1.80k| ctx.error = error_code::none; 3622| 1.80k| } 3623| 1.80k| } 3624| 1.80k| } 3625| 1.80k| else { 3626| 1.80k| it = copy_it; 3627| 1.80k| rewind_depth(ctx, copy_depth); 3628| 1.80k| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 1.80k| not variant_alternative_exhausted(ctx)) { 3630| 1.80k| ctx.error = error_code::none; 3631| 1.80k| } 3632| 1.80k| } 3633| 1.80k| } 3634| 1.80k| else { 3635| 1.80k| it = copy_it; 3636| 1.80k| rewind_depth(ctx, copy_depth); 3637| 1.80k| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 1.80k| not variant_alternative_exhausted(ctx)) { 3639| 1.80k| ctx.error = error_code::none; 3640| 1.80k| } 3641| 1.80k| } 3642| 1.80k| ++non_const_idx; 3643| 1.80k| } 3644| 1.80k| }); 3645| 1.80k| if (!found_match) { ------------------ | Branch (3645:20): [True: 343, False: 1.46k] ------------------ 3646| 343| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 343| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 1.80k| } 3659| 1.80k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3589| 1.80k| for_each([&]() { 3590| 1.80k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 1.80k] | Branch (3590:38): [True: 0, False: 1.80k] | Branch (3590:51): [True: 0, False: 1.80k] ------------------ 3591| 0| return; 3592| 0| } 3593| 1.80k| using V = std::variant_alternative_t; 3594| 1.80k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 1.80k| auto copy_it{it}; 3596| 1.80k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 1.80k| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 66, False: 1.73k] ------------------ 3598| 66| value = V{}; 3599| 66| } 3600| 1.80k| parse::op()>(std::get(value), ctx, it, end); 3601| 1.80k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 557, False: 1.24k] | Branch (3601:45): [True: 0, False: 557] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 1.80k| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 1.24k, False: 557] ------------------ 3605| 1.24k| found_match = true; 3606| 1.24k| } 3607| 557| else if constexpr (not Options.null_terminated) { 3608| 557| constexpr bool is_complete_type = 3609| 557| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [Folded, False: 0] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [True: 0, Folded] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| 557| if constexpr (is_complete_type) { 3612| 557| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3612:32): [True: 214, False: 343] | Branch (3612:72): [True: 214, False: 0] | Branch (3612:88): [True: 214, False: 0] ------------------ 3613| 214| found_match = true; 3614| 214| ctx.error = error_code::none; 3615| 214| } 3616| 343| else { 3617| 343| it = copy_it; 3618| 343| rewind_depth(ctx, copy_depth); 3619| 343| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3619:35): [True: 0, False: 343] | Branch (3619:74): [True: 0, False: 0] ------------------ 3620| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3620:35): [True: 0, False: 0] ------------------ 3621| 0| ctx.error = error_code::none; 3622| 0| } 3623| 343| } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 1.80k| ++non_const_idx; 3643| 1.80k| } 3644| 1.80k| }); _ZN3glz29variant_alternative_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 3509| 6.55M| { 3510| 6.55M| return ctx.error == error_code::exceeded_max_recursive_depth; 3511| 6.55M| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 1.65M| { 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.65M| else { 60| 1.65M| using V = std::remove_cvref_t; 61| 1.65M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.65M| end); 63| 1.65M| } 64| 1.65M| } _ZN3glz12rewind_depthITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextEEEvRT0_j: 3492| 52.7k| { 3493| 52.7k| if (ctx.error == error_code::exceeded_max_recursive_depth) [[unlikely]] { ------------------ | Branch (3493:11): [True: 0, False: 52.7k] ------------------ 3494| 0| return; 3495| 0| } 3496| | if constexpr (Opts.null_terminated) { 3497| | ctx.depth = depth; 3498| | } 3499| 52.7k| else { 3500| 52.7k| if (ctx.error != error_code::end_reached && ctx.error != error_code::unexpected_end) { ------------------ | Branch (3500:14): [True: 49.7k, False: 2.92k] | Branch (3500:54): [True: 49.7k, False: 2] ------------------ 3501| 49.7k| ctx.depth = depth; 3502| 49.7k| } 3503| 52.7k| } 3504| 52.7k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3589| 1.80k| for_each([&]() { 3590| 1.80k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 1.46k, False: 343] | Branch (3590:38): [True: 0, False: 343] | Branch (3590:51): [True: 0, False: 343] ------------------ 3591| 1.46k| return; 3592| 1.46k| } 3593| 343| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 343| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3520| 17| { 3521| 17| constexpr auto category_count = variant_count_v; 3522| | 3523| 17| if constexpr (category_count == 0) { 3524| 17| ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| | else { 3527| | constexpr auto N = std::variant_size_v; 3528| | constexpr auto const_count = variant_filtered_count_v; 3529| | constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| | bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| | bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| | if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| | size_t non_const_idx = 0; 3588| | 3589| | for_each([&]() { 3590| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| | return; 3592| | } 3593| | using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| | }); 3645| | if (!found_match) { 3646| | if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| | } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| | } 3659| 17| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3520| 265| { 3521| 265| constexpr auto category_count = variant_count_v; 3522| | 3523| 265| if constexpr (category_count == 0) { 3524| 265| ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| | else { 3527| | constexpr auto N = std::variant_size_v; 3528| | constexpr auto const_count = variant_filtered_count_v; 3529| | constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| | bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| | bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| | if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| | size_t non_const_idx = 0; 3588| | 3589| | for_each([&]() { 3590| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| | return; 3592| | } 3593| | using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| | }); 3645| | if (!found_match) { 3646| | if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| | } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| | } 3659| 265| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm8EEEDav: 490| 508| 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_: 312| 508| { 313| 508| static constexpr auto Key = get(reflect::keys); 314| 508| static constexpr auto KeyWithEndQuote = join_v>; 315| 508| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 508| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 501, False: 7] | Branch (321:52): [True: 330, False: 171] ------------------ 322| 330| it += Length; 323| 330| if constexpr (not Opts.null_terminated) { 324| 330| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 330] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 330| } 329| | 330| 330| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 330] ------------------ 331| 0| return; 332| 0| } 333| 330| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 24, False: 306] ------------------ 334| 24| return; 335| 24| } 336| 306| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 306] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 306| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 306| } 343| 178| else [[unlikely]] { 344| 178| decode_index_unknown_key(value, ctx, it, end); 345| 178| } 346| 508| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 306| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 306| else { 274| 306| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 306| else { 298| 306| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 306| it, end); 300| 306| } 301| 306| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 306| } _ZN3glz4fromILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 1921| 306| { 1922| | if constexpr (!check_ws_handled(Opts)) { 1923| | if (skip_ws(ctx, it, end)) { 1924| | return; 1925| | } 1926| | } 1927| 306| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1927:14): [True: 22, False: 284] ------------------ 1928| 22| return; 1929| 22| } 1930| 284| skip_string_view(ctx, it, end); 1931| 284| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1931:14): [True: 0, False: 284] ------------------ 1932| 0| return; 1933| 284| if (match<'"'>(ctx, it)) { ------------------ | Branch (1933:14): [True: 0, False: 284] ------------------ 1934| 0| return; 1935| 0| } 1936| 284| if constexpr (not Opts.null_terminated) { 1937| 284| if (it == end) { ------------------ | Branch (1937:17): [True: 0, False: 284] ------------------ 1938| 0| ctx.error = error_code::end_reached; 1939| 0| return; 1940| 0| } 1941| 284| } 1942| 284| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm9EEEDav: 490| 434| 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_: 312| 434| { 313| 434| static constexpr auto Key = get(reflect::keys); 314| 434| static constexpr auto KeyWithEndQuote = join_v>; 315| 434| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 434| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 426, False: 8] | Branch (321:52): [True: 422, False: 4] ------------------ 322| 422| it += Length; 323| 422| if constexpr (not Opts.null_terminated) { 324| 422| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 422] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 422| } 329| | 330| 422| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 422] ------------------ 331| 0| return; 332| 0| } 333| 422| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 28, False: 394] ------------------ 334| 28| return; 335| 28| } 336| 394| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 394] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 394| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 394| } 343| 12| else [[unlikely]] { 344| 12| decode_index_unknown_key(value, ctx, it, end); 345| 12| } 346| 434| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 394| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 394| else { 274| 394| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 394| else { 298| 394| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 394| it, end); 300| 394| } 301| 394| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 394| } _ZN3glz4fromILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEESC_TkNS_10is_contextERNS_7contextERPKcSJ_EEvRT0_OT1_OT2_T3_: 1921| 394| { 1922| | if constexpr (!check_ws_handled(Opts)) { 1923| | if (skip_ws(ctx, it, end)) { 1924| | return; 1925| | } 1926| | } 1927| 394| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1927:14): [True: 26, False: 368] ------------------ 1928| 26| return; 1929| 26| } 1930| 368| skip_string_view(ctx, it, end); 1931| 368| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1931:14): [True: 0, False: 368] ------------------ 1932| 0| return; 1933| 368| if (match<'"'>(ctx, it)) { ------------------ | Branch (1933:14): [True: 0, False: 368] ------------------ 1934| 0| return; 1935| 0| } 1936| 368| if constexpr (not Opts.null_terminated) { 1937| 368| if (it == end) { ------------------ | Branch (1937:17): [True: 0, False: 368] ------------------ 1938| 0| ctx.error = error_code::end_reached; 1939| 0| return; 1940| 0| } 1941| 368| } 1942| 368| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm10EEEDav: 490| 444| 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_: 312| 444| { 313| 444| static constexpr auto Key = get(reflect::keys); 314| 444| static constexpr auto KeyWithEndQuote = join_v>; 315| 444| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 444| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 438, False: 6] | Branch (321:52): [True: 396, False: 42] ------------------ 322| 396| it += Length; 323| 396| if constexpr (not Opts.null_terminated) { 324| 396| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 396] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 396| } 329| | 330| 396| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 396] ------------------ 331| 0| return; 332| 0| } 333| 396| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 51, False: 345] ------------------ 334| 51| return; 335| 51| } 336| 345| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 345] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 345| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 345| } 343| 48| else [[unlikely]] { 344| 48| decode_index_unknown_key(value, ctx, it, end); 345| 48| } 346| 444| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 345| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 345| else { 274| 345| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 345| else { 298| 345| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 345| it, end); 300| 345| } 301| 345| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 345| } _ZN3glz4fromILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES8_TkNS_10is_contextERNS_7contextERPKcSF_EEvRT0_OT1_OT2_T3_: 1921| 345| { 1922| | if constexpr (!check_ws_handled(Opts)) { 1923| | if (skip_ws(ctx, it, end)) { 1924| | return; 1925| | } 1926| | } 1927| 345| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1927:14): [True: 28, False: 317] ------------------ 1928| 28| return; 1929| 28| } 1930| 317| skip_string_view(ctx, it, end); 1931| 317| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1931:14): [True: 0, False: 317] ------------------ 1932| 0| return; 1933| 317| if (match<'"'>(ctx, it)) { ------------------ | Branch (1933:14): [True: 0, False: 317] ------------------ 1934| 0| return; 1935| 0| } 1936| 317| if constexpr (not Opts.null_terminated) { 1937| 317| if (it == end) { ------------------ | Branch (1937:17): [True: 0, False: 317] ------------------ 1938| 0| ctx.error = error_code::end_reached; 1939| 0| return; 1940| 0| } 1941| 317| } 1942| 317| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm11EEEDav: 490| 328| 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_: 312| 328| { 313| 328| static constexpr auto Key = get(reflect::keys); 314| 328| static constexpr auto KeyWithEndQuote = join_v>; 315| 328| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 328| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 323, False: 5] | Branch (321:52): [True: 320, False: 3] ------------------ 322| 320| it += Length; 323| 320| if constexpr (not Opts.null_terminated) { 324| 320| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 320] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 320| } 329| | 330| 320| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 320] ------------------ 331| 0| return; 332| 0| } 333| 320| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 28, False: 292] ------------------ 334| 28| return; 335| 28| } 336| 292| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 292] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 292| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 292| } 343| 8| else [[unlikely]] { 344| 8| decode_index_unknown_key(value, ctx, it, end); 345| 8| } 346| 328| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 292| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 292| else { 274| 292| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 292| else { 298| 292| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 292| it, end); 300| 292| } 301| 292| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 292| } _ZN3glz4fromILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES9_TkNS_10is_contextERNS_7contextERPKcSG_EEvRT0_OT1_OT2_T3_: 1921| 292| { 1922| | if constexpr (!check_ws_handled(Opts)) { 1923| | if (skip_ws(ctx, it, end)) { 1924| | return; 1925| | } 1926| | } 1927| 292| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1927:14): [True: 32, False: 260] ------------------ 1928| 32| return; 1929| 32| } 1930| 260| skip_string_view(ctx, it, end); 1931| 260| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1931:14): [True: 0, False: 260] ------------------ 1932| 0| return; 1933| 260| if (match<'"'>(ctx, it)) { ------------------ | Branch (1933:14): [True: 0, False: 260] ------------------ 1934| 0| return; 1935| 0| } 1936| 260| if constexpr (not Opts.null_terminated) { 1937| 260| if (it == end) { ------------------ | Branch (1937:17): [True: 0, False: 260] ------------------ 1938| 0| ctx.error = error_code::end_reached; 1939| 0| return; 1940| 0| } 1941| 260| } 1942| 260| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm12EEEDav: 490| 226| 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_: 312| 226| { 313| 226| static constexpr auto Key = get(reflect::keys); 314| 226| static constexpr auto KeyWithEndQuote = join_v>; 315| 226| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 226| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 221, False: 5] | Branch (321:52): [True: 218, False: 3] ------------------ 322| 218| it += Length; 323| 218| if constexpr (not Opts.null_terminated) { 324| 218| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 218] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 218| } 329| | 330| 218| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 218] ------------------ 331| 0| return; 332| 0| } 333| 218| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 29, False: 189] ------------------ 334| 29| return; 335| 29| } 336| 189| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 189] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 189| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 189| } 343| 8| else [[unlikely]] { 344| 8| decode_index_unknown_key(value, ctx, it, end); 345| 8| } 346| 226| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 189| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 189| else { 274| 189| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| | else if constexpr (glaze_object_t) { 294| | from>::template op(get_member(value, get(reflect::values)), 295| | ctx, it, end); 296| | } 297| 189| else { 298| 189| from>::template op(get_member(value, get(to_tie(value))), ctx, 299| 189| it, end); 300| 189| } 301| 189| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 189| } _ZN3glz4fromILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 1921| 189| { 1922| | if constexpr (!check_ws_handled(Opts)) { 1923| | if (skip_ws(ctx, it, end)) { 1924| | return; 1925| | } 1926| | } 1927| 189| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1927:14): [True: 26, False: 163] ------------------ 1928| 26| return; 1929| 26| } 1930| 163| skip_string_view(ctx, it, end); 1931| 163| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1931:14): [True: 0, False: 163] ------------------ 1932| 0| return; 1933| 163| if (match<'"'>(ctx, it)) { ------------------ | Branch (1933:14): [True: 0, False: 163] ------------------ 1934| 0| return; 1935| 0| } 1936| 163| if constexpr (not Opts.null_terminated) { 1937| 163| if (it == end) { ------------------ | Branch (1937:17): [True: 0, False: 163] ------------------ 1938| 0| ctx.error = error_code::end_reached; 1939| 0| return; 1940| 0| } 1941| 163| } 1942| 163| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 1.81k| { 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.81k| else { 60| 1.81k| using V = std::remove_cvref_t; 61| 1.81k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.81k| end); 63| 1.81k| } 64| 1.81k| } _ZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 1.81k| { 2792| 1.81k| static constexpr auto num_members = reflect::size; 2793| | 2794| 1.81k| static constexpr auto Opts = opening_handled_off()>(); 2795| 1.81k| if constexpr (!check_opening_handled(Options)) { 2796| 1.81k| if constexpr (!check_ws_handled(Options)) { 2797| 1.81k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2797:20): [True: 0, False: 1.81k] ------------------ 2798| 0| return; 2799| 0| } 2800| 1.81k| } 2801| 1.81k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 63, False: 1.74k] ------------------ 2802| 63| return; 2803| 63| } 2804| 1.74k| if constexpr (not Opts.null_terminated) { 2805| 1.74k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 1.74k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 1.74k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 1.74k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 1.74k] ------------------ 2813| 0| return; 2814| 0| } 2815| 1.74k| } 2816| 1.74k| const auto ws_start = it; 2817| 1.81k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 1.81k] ------------------ 2818| 0| return; 2819| 0| } 2820| 1.81k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 1.81k| else { 2895| 1.81k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 1.81k| if constexpr ((glaze_object_t || reflectable) && 2897| 1.81k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 1.81k| return bit_array{}; 2899| 1.81k| } 2900| 1.81k| else { 2901| 1.81k| return nullptr; 2902| 1.81k| } 2903| 1.81k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 1.81k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 1.81k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 1.81k| return has_includer_member; 2915| 1.81k| } 2916| 1.81k| else { 2917| 1.81k| return false; 2918| 1.81k| } 2919| 1.81k| }(); 2920| 1.81k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 1.81k| [[maybe_unused]] const std::conditional_t>, 2930| 1.81k| inert_key_bits_scope> published_bits{ 2931| 1.81k| ctx, [&]() -> void* { 2932| 1.81k| if constexpr (tracks_include_keys) { 2933| 1.81k| return &fields; 2934| 1.81k| } 2935| 1.81k| else { 2936| 1.81k| return nullptr; 2937| 1.81k| } 2938| 1.81k| }()}; 2939| | 2940| 1.81k| size_t read_count{}; // for partial_read 2941| | 2942| 1.81k| bool first = true; 2943| 16.0k| while (true) { ------------------ | Branch (2943:20): [True: 14.6k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 14.6k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 289, False: 14.3k] ------------------ 2981| 289| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 289| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 289| } 3017| 289| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 289| if constexpr (not Opts.null_terminated) { 3019| 289| if (it == end) { ------------------ | Branch (3019:26): [True: 289, False: 0] ------------------ 3020| 289| ctx.error = error_code::end_reached; 3021| 289| return; 3022| 289| } 3023| 289| } 3024| 0| return; 3025| 289| } 3026| 14.3k| else if (first) { ------------------ | Branch (3026:25): [True: 1.71k, False: 12.6k] ------------------ 3027| 1.71k| first = false; 3028| 1.71k| } 3029| 12.6k| else { 3030| 12.6k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 141, False: 12.5k] ------------------ 3031| 141| return; 3032| 141| } 3033| 12.5k| if constexpr (not Opts.null_terminated) { 3034| 12.5k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 12.5k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 12.5k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 12.5k| (!Opts.comments)) { 3042| 12.5k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 11.0k, False: 1.48k] | Branch (3042:37): [True: 10.7k, False: 258] ------------------ 3043| 10.7k| skip_matching_ws(ws_start, it, ws_size); 3044| 10.7k| } 3045| 12.5k| } 3046| | 3047| 12.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 12.5k] ------------------ 3048| 0| return; 3049| 0| } 3050| 12.5k| } 3051| | 3052| 14.2k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [True: 0, Folded] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 14.2k| else if constexpr (reflection_type) { 3118| 14.2k| static_assert(bool(hash_info.type)); 3119| | 3120| 14.2k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 798, False: 13.4k] ------------------ 3121| 798| ctx.error = error_code::expected_quote; 3122| 798| return; 3123| 798| } 3124| 13.4k| ++it; 3125| 13.4k| if constexpr (not Opts.null_terminated) { 3126| 13.4k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 0, False: 13.4k] ------------------ 3127| 0| ctx.error = error_code::unexpected_end; 3128| 0| return; 3129| 0| } 3130| 13.4k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 13.4k| else { 3181| 13.4k| parse_and_invoke(value, ctx, it, end); 3182| 13.4k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 519, False: 12.9k] ------------------ 3183| 519| return; 3184| 13.4k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 14.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 14.2k] ------------------ 3294| 0| return; 3295| 0| } 3296| 14.2k| } 3297| 1.81k| } 3298| 1.81k| } _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 1.74k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 1.74k| else { 2901| 1.74k| return nullptr; 2902| 1.74k| } 2903| 1.74k| }(); _ZZN3glz4fromILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 1.74k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 1.74k| else { 2936| 1.74k| return nullptr; 2937| 1.74k| } 2938| 1.74k| }()}; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS4_9allocatorIiEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 1.93k| { 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.93k| else { 60| 1.93k| using V = std::remove_cvref_t; 61| 1.93k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.93k| end); 63| 1.93k| } 64| 1.93k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2050| 1.93k| { 2051| 1.93k| constexpr auto Opts = ws_handled_off(); 2052| 1.93k| if constexpr (!check_ws_handled(Options)) { 2053| 1.93k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2053:17): [True: 0, False: 1.93k] ------------------ 2054| 0| return; 2055| 0| } 2056| 1.93k| } 2057| | 2058| 1.93k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2058:14): [True: 55, False: 1.87k] ------------------ 2059| 55| return; 2060| 55| } 2061| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2062| | // released at each syntactic close below 2063| 1.87k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2063:14): [True: 0, False: 1.87k] ------------------ 2064| 0| return; 2065| 0| } 2066| | 2067| 1.87k| const auto ws_start = it; 2068| 1.87k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2068:14): [True: 0, False: 1.87k] ------------------ 2069| 0| return; 2070| 0| } 2071| | 2072| 1.87k| if (*it == ']') { ------------------ | Branch (2072:14): [True: 22, False: 1.85k] ------------------ 2073| 22| --ctx.depth; 2074| 22| ++it; 2075| 22| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2076| 22| value.clear(); 2077| | 2078| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2079| | value.shrink_to_fit(); 2080| | } 2081| 22| } 2082| 22| return; 2083| 22| } 2084| | 2085| 1.85k| const size_t ws_size = size_t(it - ws_start); 2086| | 2087| 1.85k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2087:49): [True: 1.85k, Folded] | Branch (2087:65): [Folded, False: 0] | Branch (2087:90): [Folded, False: 0] ------------------ 2088| 1.85k| if constexpr (not should_append) { 2089| 1.85k| const auto n = value.size(); 2090| | 2091| 1.85k| auto value_it = value.begin(); 2092| | 2093| 1.85k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2093:32): [True: 0, False: 1.85k] ------------------ 2094| 0| parse::op()>(*value_it++, ctx, it, end); 2095| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2095:20): [True: 0, False: 0] ------------------ 2096| 0| return; 2097| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2097:20): [True: 0, False: 0] ------------------ 2098| 0| return; 2099| 0| } 2100| 0| if (*it == ',') { ------------------ | Branch (2100:20): [True: 0, False: 0] ------------------ 2101| 0| ++it; 2102| | 2103| 0| if constexpr (!Opts.minified && !Opts.comments) { 2104| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2104:26): [True: 0, False: 0] | Branch (2104:37): [True: 0, False: 0] ------------------ 2105| 0| skip_matching_ws(ws_start, it, ws_size); 2106| 0| } 2107| 0| } 2108| | 2109| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2109:23): [True: 0, False: 0] ------------------ 2110| 0| return; 2111| 0| } 2112| 0| } 2113| 0| else if (*it == ']') { ------------------ | Branch (2113:25): [True: 0, False: 0] ------------------ 2114| 0| --ctx.depth; 2115| 0| ++it; 2116| 0| if constexpr (erasable) { 2117| 0| value.erase(value_it, 2118| 0| value.end()); // use erase rather than resize for non-default constructible elements 2119| | 2120| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2121| | value.shrink_to_fit(); 2122| | } 2123| 0| } 2124| 0| return; 2125| 0| } 2126| 0| else [[unlikely]] { 2127| 0| ctx.error = error_code::expected_bracket; 2128| 0| return; 2129| 0| } 2130| 0| } 2131| 1.85k| } 2132| | 2133| | if constexpr (Opts.partial_read) { 2134| | // partial_read stops early on a success path, so give the level back like the 2135| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2136| | --ctx.depth; 2137| | return; 2138| | } 2139| 1.85k| else { 2140| | // growing 2141| 1.85k| if constexpr (emplace_backable || has_try_emplace_back) { 2142| 240k| while (it < end) { ------------------ | Branch (2142:23): [True: 240k, False: 0] ------------------ 2143| | // Streaming refill point: at start of each iteration, ensure buffer has data 2144| | if constexpr (has_streaming_state) { 2145| | if (ctx.stream.enabled()) { 2146| | const size_t consumed = static_cast(it - ctx.stream.data()); 2147| | const size_t remaining = ctx.stream.size() - consumed; 2148| | // Refill when less than half of buffer remains to ensure space for next element 2149| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2150| | const char* new_it; 2151| | const char* new_end; 2152| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2153| | it = new_it; 2154| | end = new_end; 2155| | if (it >= end && ctx.stream.at_eof()) { 2156| | break; // No more data, exit loop normally 2157| | } 2158| | } 2159| | } 2160| | } 2161| | 2162| | if constexpr (has_try_emplace_back) { 2163| | if (value.try_emplace_back()) 2164| | parse::op()>(value.back(), ctx, it, end); 2165| | else 2166| | ctx.error = error_code::exceeded_static_array_size; 2167| | } 2168| 240k| else { 2169| 240k| parse::op()>(value.emplace_back(), ctx, it, end); 2170| 240k| } 2171| | 2172| 240k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2172:23): [True: 1.05k, False: 239k] ------------------ 2173| 1.05k| return; 2174| | 2175| | // Streaming refill point: after parsing each element, refill if buffer is low 2176| | if constexpr (has_streaming_state) { 2177| | if (ctx.stream.enabled()) { 2178| | const size_t consumed = static_cast(it - ctx.stream.data()); 2179| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2180| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2181| | const char* new_it; 2182| | const char* new_end; 2183| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2184| | it = new_it; 2185| | end = new_end; 2186| | if (it >= end && ctx.stream.at_eof()) { 2187| | ctx.error = error_code::unexpected_end; 2188| | return; 2189| | } 2190| | } 2191| | } 2192| | } 2193| | 2194| 239k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2194:23): [True: 0, False: 239k] ------------------ 2195| 0| return; 2196| 0| } 2197| 239k| if (*it == ',') [[likely]] { ------------------ | Branch (2197:23): [True: 238k, False: 799] ------------------ 2198| 238k| ++it; 2199| | 2200| 238k| if constexpr (!Opts.minified && !Opts.comments) { 2201| 238k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2201:29): [True: 128k, False: 109k] | Branch (2201:40): [True: 128k, False: 320] ------------------ 2202| 128k| skip_matching_ws(ws_start, it, ws_size); 2203| 128k| } 2204| 238k| } 2205| | 2206| 238k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2206:26): [True: 0, False: 238k] ------------------ 2207| 0| return; 2208| 0| } 2209| 238k| } 2210| 799| else if (*it == ']') { ------------------ | Branch (2210:28): [True: 420, False: 379] ------------------ 2211| 420| --ctx.depth; 2212| 420| ++it; 2213| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2214| | value.shrink_to_fit(); 2215| | } 2216| 420| return; 2217| 420| } 2218| 379| else [[unlikely]] { 2219| 379| ctx.error = error_code::expected_bracket; 2220| 379| return; 2221| 379| } 2222| 239k| } 2223| | 2224| | // A valid array always returns from inside the loop upon reaching ']'. 2225| | // For a null-terminated buffer the loop can only exit here by falling 2226| | // through when `it` reaches the terminator without a closing bracket, 2227| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2228| | // Non-null-terminated buffers surface this through skip_ws/depth 2229| | // tracking (or the streaming refill break), so this guard is limited 2230| | // to the null-terminated case. 2231| | if constexpr (Opts.null_terminated) { 2232| | ctx.error = error_code::unexpected_end; 2233| | } 2234| | } 2235| | else { 2236| | ctx.error = error_code::exceeded_static_array_size; 2237| | } 2238| 1.85k| } 2239| 1.85k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEETkNS_10is_contextERNS_7contextERPKcSN_EEvOT0_OT1_OT2_T3_: 49| 1.64k| { 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.64k| else { 60| 1.64k| using V = std::remove_cvref_t; 61| 1.64k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.64k| end); 63| 1.64k| } 64| 1.64k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 2791| 1.64k| { 2792| 1.64k| static constexpr auto num_members = reflect::size; 2793| | 2794| 1.64k| static constexpr auto Opts = opening_handled_off()>(); 2795| 1.64k| if constexpr (!check_opening_handled(Options)) { 2796| 1.64k| if constexpr (!check_ws_handled(Options)) { 2797| 1.64k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2797:20): [True: 0, False: 1.64k] ------------------ 2798| 0| return; 2799| 0| } 2800| 1.64k| } 2801| 1.64k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 73, False: 1.57k] ------------------ 2802| 73| return; 2803| 73| } 2804| 1.57k| if constexpr (not Opts.null_terminated) { 2805| 1.57k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 1.57k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 1.57k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 1.57k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 1.57k] ------------------ 2813| 0| return; 2814| 0| } 2815| 1.57k| } 2816| 1.57k| const auto ws_start = it; 2817| 1.64k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 1.64k] ------------------ 2818| 0| return; 2819| 0| } 2820| 1.64k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 1.64k| else { 2895| 1.64k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 1.64k| if constexpr ((glaze_object_t || reflectable) && 2897| 1.64k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 1.64k| return bit_array{}; 2899| 1.64k| } 2900| 1.64k| else { 2901| 1.64k| return nullptr; 2902| 1.64k| } 2903| 1.64k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 1.64k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 1.64k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 1.64k| return has_includer_member; 2915| 1.64k| } 2916| 1.64k| else { 2917| 1.64k| return false; 2918| 1.64k| } 2919| 1.64k| }(); 2920| 1.64k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 1.64k| [[maybe_unused]] const std::conditional_t>, 2930| 1.64k| inert_key_bits_scope> published_bits{ 2931| 1.64k| ctx, [&]() -> void* { 2932| 1.64k| if constexpr (tracks_include_keys) { 2933| 1.64k| return &fields; 2934| 1.64k| } 2935| 1.64k| else { 2936| 1.64k| return nullptr; 2937| 1.64k| } 2938| 1.64k| }()}; 2939| | 2940| 1.64k| size_t read_count{}; // for partial_read 2941| | 2942| 1.64k| bool first = true; 2943| 22.3k| while (true) { ------------------ | Branch (2943:20): [True: 21.3k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 21.3k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 373, False: 20.9k] ------------------ 2981| 373| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| | if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| | } 3017| 373| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 373| if constexpr (not Opts.null_terminated) { 3019| 373| if (it == end) { ------------------ | Branch (3019:26): [True: 373, False: 0] ------------------ 3020| 373| ctx.error = error_code::end_reached; 3021| 373| return; 3022| 373| } 3023| 373| } 3024| 0| return; 3025| 373| } 3026| 20.9k| else if (first) { ------------------ | Branch (3026:25): [True: 1.54k, False: 19.4k] ------------------ 3027| 1.54k| first = false; 3028| 1.54k| } 3029| 19.4k| else { 3030| 19.4k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 242, False: 19.1k] ------------------ 3031| 242| return; 3032| 242| } 3033| 19.1k| if constexpr (not Opts.null_terminated) { 3034| 19.1k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 19.1k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 19.1k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| | (!Opts.comments)) { 3042| | if (ws_size && ws_size < size_t(end - it)) { 3043| | skip_matching_ws(ws_start, it, ws_size); 3044| | } 3045| | } 3046| | 3047| 19.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 19.1k] ------------------ 3048| 0| return; 3049| 0| } 3050| 19.1k| } 3051| | 3052| 20.7k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [Folded, False: 0] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| | else if constexpr (reflection_type) { 3118| | static_assert(bool(hash_info.type)); 3119| | 3120| | if (*it != '"') [[unlikely]] { 3121| | ctx.error = error_code::expected_quote; 3122| | return; 3123| | } 3124| | ++it; 3125| | if constexpr (not Opts.null_terminated) { 3126| | if (it == end) [[unlikely]] { 3127| | ctx.error = error_code::unexpected_end; 3128| | return; 3129| | } 3130| | } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| | else { 3181| | parse_and_invoke(value, ctx, it, end); 3182| | if (bool(ctx.error)) [[unlikely]] 3183| | return; 3184| | } 3185| | } 3186| 20.7k| else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| 20.7k| auto reading = [&](auto&& key) { 3190| 20.7k| if constexpr (Opts.partial_read) { 3191| 20.7k| if (auto element = value.find(key); element != value.end()) { 3192| 20.7k| ++read_count; 3193| 20.7k| parse::op()>(element->second, ctx, it, end); 3194| 20.7k| } 3195| 20.7k| else { 3196| 20.7k| skip_value::op(ctx, it, end); 3197| 20.7k| } 3198| 20.7k| } 3199| 20.7k| else { 3200| 20.7k| parse::op()>(value[key], ctx, it, end); 3201| 20.7k| } 3202| 20.7k| }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| 20.7k| using Key = typename T::key_type; 3206| 20.7k| if constexpr (std::is_same_v) { 3207| 20.7k| ctx.scratch.clear(); 3208| 20.7k| parse::op(ctx.scratch, ctx, it, end); 3209| 20.7k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3209:26): [True: 214, False: 20.5k] ------------------ 3210| 214| return; 3211| | 3212| 20.5k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3212:26): [True: 166, False: 20.3k] ------------------ 3213| 166| return; 3214| 166| } 3215| | 3216| 20.3k| reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| 20.3k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3222:26): [True: 576, False: 19.7k] ------------------ 3223| 576| return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| 20.7k| } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 20.7k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 20.7k] ------------------ 3294| 0| return; 3295| 0| } 3296| 20.7k| } 3297| 1.64k| } 3298| 1.64k| } _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: 2895| 1.57k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 1.57k| else { 2901| 1.57k| return nullptr; 2902| 1.57k| } 2903| 1.57k| }(); _ZZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 1.57k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 1.57k| else { 2936| 1.57k| return nullptr; 2937| 1.57k| } 2938| 1.57k| }()}; _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_: 3189| 20.3k| auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| 20.3k| else { 3200| 20.3k| parse::op()>(value[key], ctx, it, end); 3201| 20.3k| } 3202| 20.3k| }; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 49| 2.15k| { 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.15k| else { 60| 2.15k| using V = std::remove_cvref_t; 61| 2.15k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 2.15k| end); 63| 2.15k| } 64| 2.15k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 4883| 2.15k| { 4884| 2.15k| constexpr auto Opts = ws_handled_off(); 4885| 2.15k| if constexpr (!check_ws_handled(Options)) { 4886| 2.15k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (4886:17): [True: 0, False: 2.15k] ------------------ 4887| 0| return; 4888| 0| } 4889| 2.15k| } 4890| | 4891| 2.15k| if (*it == 'n') { ------------------ | Branch (4891:14): [True: 0, False: 2.15k] ------------------ 4892| 0| ++it; 4893| 0| if constexpr (not Opts.null_terminated) { 4894| 0| if (it == end) [[unlikely]] { ------------------ | Branch (4894:20): [True: 0, False: 0] ------------------ 4895| 0| ctx.error = error_code::unexpected_end; 4896| 0| return; 4897| 0| } 4898| 0| } 4899| 0| match<"ull", Opts>(ctx, it, end); 4900| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (4900:17): [True: 0, False: 0] ------------------ 4901| 0| return; 4902| 0| if constexpr (requires { value.reset(); }) { 4903| 0| value.reset(); 4904| 0| } 4905| 0| } 4906| 2.15k| else { 4907| 2.15k| if constexpr (nullable_value_t) { 4908| 2.15k| if (not value.has_value()) { ------------------ | Branch (4908:20): [True: 2.15k, False: 0] ------------------ 4909| | if constexpr (constructible) { 4910| | value = meta_construct_v(); 4911| | } 4912| 2.15k| else if constexpr (requires { value.emplace(); }) { 4913| 2.15k| value.emplace(); 4914| | } 4915| | else { 4916| | static_assert(false_v, 4917| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 4918| | "create a custom glz::from specialization"); 4919| | } 4920| 2.15k| } 4921| 2.15k| parse::op(value.value(), ctx, it, end); 4922| | } 4923| | else { 4924| | if (!value) { 4925| | if (!nullable_emplace(value, ctx)) { 4926| | return; 4927| | } 4928| | } 4929| | parse::op(*value, ctx, it, end); 4930| | } 4931| 2.15k| } 4932| 2.15k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 49| 1.29k| { 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.29k| else { 60| 1.29k| using V = std::remove_cvref_t; 61| 1.29k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.29k| end); 63| 1.29k| } 64| 1.29k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 3860| 1.29k| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 1.29k| else { 3865| 1.29k| read_deduced(value, ctx, it, end); 3866| 1.29k| } 3867| 1.29k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 3871| 1.29k| { 3872| 1.29k| constexpr auto Opts = ws_handled_off(); 3873| 1.29k| if constexpr (variant_is_auto_deducible()) { 3874| 1.29k| if constexpr (not check_ws_handled(Options)) { 3875| 1.29k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3875:20): [True: 0, False: 1.29k] ------------------ 3876| 0| return; 3877| 0| } 3878| 1.29k| } 3879| | 3880| 1.29k| switch (*it) { 3881| 0| case '\0': ------------------ | Branch (3881:13): [True: 0, False: 1.29k] ------------------ 3882| 0| ctx.error = error_code::unexpected_end; 3883| 0| return; 3884| 263| case '{': { ------------------ | Branch (3884:13): [True: 263, False: 1.03k] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 263| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 263] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 263| ++it; 3894| 263| if constexpr (not Opts.null_terminated) { 3895| 263| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 0, False: 263] ------------------ 3896| 0| ctx.error = error_code::unexpected_end; 3897| 0| return; 3898| 0| } 3899| 263| } 3900| 263| using type_counts = variant_type_count; 3901| 263| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| | if constexpr (n_object_candidates < 1) { 3903| | ctx.error = error_code::no_matching_variant_type; 3904| | return; 3905| | } 3906| 263| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| 263| constexpr auto first_idx = variant_first_object_candidate_v; 3908| 263| using V = std::variant_alternative_t; 3909| 263| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (3909:23): [True: 263, False: 0] ------------------ 3910| 263| parse::op()>(std::get(value), ctx, it, end); 3911| 263| return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 263| } 4596| 23| case '[': ------------------ | Branch (4596:13): [True: 23, False: 1.27k] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 23| process_variant_alternatives::template op(value, ctx, it, end); 4599| 23| break; 4600| 759| case '"': { ------------------ | Branch (4600:13): [True: 759, False: 540] ------------------ 4601| 759| process_variant_alternatives::template op(value, ctx, it, end); 4602| 759| break; 4603| 263| } 4604| 8| case 't': ------------------ | Branch (4604:13): [True: 8, False: 1.29k] ------------------ 4605| 11| case 'f': { ------------------ | Branch (4605:13): [True: 3, False: 1.29k] ------------------ 4606| 11| process_variant_alternatives::template op(value, ctx, it, end); 4607| 11| break; 4608| 8| } 4609| 0| case 'n': ------------------ | Branch (4609:13): [True: 0, False: 1.29k] ------------------ 4610| 0| if constexpr (variant_count_v == 0) { 4611| 0| ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| | else { 4614| | constexpr auto first_idx = variant_first_index_v; 4615| | using V = std::variant_alternative_t; 4616| | if (!std::holds_alternative(value)) value = V{}; 4617| | match<"null", Opts>(ctx, it, end); 4618| | } 4619| 0| break; 4620| 243| default: { ------------------ | Branch (4620:13): [True: 243, False: 1.05k] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 243| process_variant_alternatives::template op(value, ctx, it, end); 4623| 243| } 4624| 1.29k| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 1.29k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS4_9allocatorIdEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 3.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| 3.62k| else { 60| 3.62k| using V = std::remove_cvref_t; 61| 3.62k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.62k| end); 63| 3.62k| } 64| 3.62k| } _ZN3glz4fromILj10ENSt3__16vectorIdNS1_9allocatorIdEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2050| 3.62k| { 2051| 3.62k| constexpr auto Opts = ws_handled_off(); 2052| 3.62k| if constexpr (!check_ws_handled(Options)) { 2053| 3.62k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2053:17): [True: 0, False: 3.62k] ------------------ 2054| 0| return; 2055| 0| } 2056| 3.62k| } 2057| | 2058| 3.62k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2058:14): [True: 116, False: 3.50k] ------------------ 2059| 116| return; 2060| 116| } 2061| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2062| | // released at each syntactic close below 2063| 3.50k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2063:14): [True: 0, False: 3.50k] ------------------ 2064| 0| return; 2065| 0| } 2066| | 2067| 3.50k| const auto ws_start = it; 2068| 3.50k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2068:14): [True: 0, False: 3.50k] ------------------ 2069| 0| return; 2070| 0| } 2071| | 2072| 3.50k| if (*it == ']') { ------------------ | Branch (2072:14): [True: 23, False: 3.48k] ------------------ 2073| 23| --ctx.depth; 2074| 23| ++it; 2075| 23| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2076| 23| value.clear(); 2077| | 2078| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2079| | value.shrink_to_fit(); 2080| | } 2081| 23| } 2082| 23| return; 2083| 23| } 2084| | 2085| 3.48k| const size_t ws_size = size_t(it - ws_start); 2086| | 2087| 3.48k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2087:49): [True: 3.48k, Folded] | Branch (2087:65): [Folded, False: 0] | Branch (2087:90): [Folded, False: 0] ------------------ 2088| 3.48k| if constexpr (not should_append) { 2089| 3.48k| const auto n = value.size(); 2090| | 2091| 3.48k| auto value_it = value.begin(); 2092| | 2093| 3.48k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2093:32): [True: 0, False: 3.48k] ------------------ 2094| 0| parse::op()>(*value_it++, ctx, it, end); 2095| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2095:20): [True: 0, False: 0] ------------------ 2096| 0| return; 2097| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2097:20): [True: 0, False: 0] ------------------ 2098| 0| return; 2099| 0| } 2100| 0| if (*it == ',') { ------------------ | Branch (2100:20): [True: 0, False: 0] ------------------ 2101| 0| ++it; 2102| | 2103| 0| if constexpr (!Opts.minified && !Opts.comments) { 2104| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2104:26): [True: 0, False: 0] | Branch (2104:37): [True: 0, False: 0] ------------------ 2105| 0| skip_matching_ws(ws_start, it, ws_size); 2106| 0| } 2107| 0| } 2108| | 2109| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2109:23): [True: 0, False: 0] ------------------ 2110| 0| return; 2111| 0| } 2112| 0| } 2113| 0| else if (*it == ']') { ------------------ | Branch (2113:25): [True: 0, False: 0] ------------------ 2114| 0| --ctx.depth; 2115| 0| ++it; 2116| 0| if constexpr (erasable) { 2117| 0| value.erase(value_it, 2118| 0| value.end()); // use erase rather than resize for non-default constructible elements 2119| | 2120| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2121| | value.shrink_to_fit(); 2122| | } 2123| 0| } 2124| 0| return; 2125| 0| } 2126| 0| else [[unlikely]] { 2127| 0| ctx.error = error_code::expected_bracket; 2128| 0| return; 2129| 0| } 2130| 0| } 2131| 3.48k| } 2132| | 2133| | if constexpr (Opts.partial_read) { 2134| | // partial_read stops early on a success path, so give the level back like the 2135| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2136| | --ctx.depth; 2137| | return; 2138| | } 2139| 3.48k| else { 2140| | // growing 2141| 3.48k| if constexpr (emplace_backable || has_try_emplace_back) { 2142| 703k| while (it < end) { ------------------ | Branch (2142:23): [True: 703k, False: 0] ------------------ 2143| | // Streaming refill point: at start of each iteration, ensure buffer has data 2144| | if constexpr (has_streaming_state) { 2145| | if (ctx.stream.enabled()) { 2146| | const size_t consumed = static_cast(it - ctx.stream.data()); 2147| | const size_t remaining = ctx.stream.size() - consumed; 2148| | // Refill when less than half of buffer remains to ensure space for next element 2149| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2150| | const char* new_it; 2151| | const char* new_end; 2152| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2153| | it = new_it; 2154| | end = new_end; 2155| | if (it >= end && ctx.stream.at_eof()) { 2156| | break; // No more data, exit loop normally 2157| | } 2158| | } 2159| | } 2160| | } 2161| | 2162| | if constexpr (has_try_emplace_back) { 2163| | if (value.try_emplace_back()) 2164| | parse::op()>(value.back(), ctx, it, end); 2165| | else 2166| | ctx.error = error_code::exceeded_static_array_size; 2167| | } 2168| 703k| else { 2169| 703k| parse::op()>(value.emplace_back(), ctx, it, end); 2170| 703k| } 2171| | 2172| 703k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2172:23): [True: 994, False: 702k] ------------------ 2173| 994| return; 2174| | 2175| | // Streaming refill point: after parsing each element, refill if buffer is low 2176| | if constexpr (has_streaming_state) { 2177| | if (ctx.stream.enabled()) { 2178| | const size_t consumed = static_cast(it - ctx.stream.data()); 2179| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2180| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2181| | const char* new_it; 2182| | const char* new_end; 2183| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2184| | it = new_it; 2185| | end = new_end; 2186| | if (it >= end && ctx.stream.at_eof()) { 2187| | ctx.error = error_code::unexpected_end; 2188| | return; 2189| | } 2190| | } 2191| | } 2192| | } 2193| | 2194| 702k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2194:23): [True: 0, False: 702k] ------------------ 2195| 0| return; 2196| 0| } 2197| 702k| if (*it == ',') [[likely]] { ------------------ | Branch (2197:23): [True: 700k, False: 2.49k] ------------------ 2198| 700k| ++it; 2199| | 2200| 700k| if constexpr (!Opts.minified && !Opts.comments) { 2201| 700k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2201:29): [True: 577k, False: 122k] | Branch (2201:40): [True: 577k, False: 276] ------------------ 2202| 577k| skip_matching_ws(ws_start, it, ws_size); 2203| 577k| } 2204| 700k| } 2205| | 2206| 700k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2206:26): [True: 0, False: 700k] ------------------ 2207| 0| return; 2208| 0| } 2209| 700k| } 2210| 2.49k| else if (*it == ']') { ------------------ | Branch (2210:28): [True: 1.82k, False: 666] ------------------ 2211| 1.82k| --ctx.depth; 2212| 1.82k| ++it; 2213| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2214| | value.shrink_to_fit(); 2215| | } 2216| 1.82k| return; 2217| 1.82k| } 2218| 666| else [[unlikely]] { 2219| 666| ctx.error = error_code::expected_bracket; 2220| 666| return; 2221| 666| } 2222| 702k| } 2223| | 2224| | // A valid array always returns from inside the loop upon reaching ']'. 2225| | // For a null-terminated buffer the loop can only exit here by falling 2226| | // through when `it` reaches the terminator without a closing bracket, 2227| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2228| | // Non-null-terminated buffers surface this through skip_ws/depth 2229| | // tracking (or the streaming refill break), so this guard is limited 2230| | // to the null-terminated case. 2231| | if constexpr (Opts.null_terminated) { 2232| | ctx.error = error_code::unexpected_end; 2233| | } 2234| | } 2235| | else { 2236| | ctx.error = error_code::exceeded_static_array_size; 2237| | } 2238| 3.48k| } 2239| 3.48k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 1.27M| { 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.27M| else { 60| 1.27M| using V = std::remove_cvref_t; 61| 1.27M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.27M| end); 63| 1.27M| } 64| 1.27M| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorINS_14basic_raw_jsonINS4_17basic_string_viewIcNS4_11char_traitsIcEEEEEENS4_9allocatorISB_EEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 49| 30.5k| { 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| 30.5k| else { 60| 30.5k| using V = std::remove_cvref_t; 61| 30.5k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 30.5k| end); 63| 30.5k| } 64| 30.5k| } _ZN3glz4fromILj10ENSt3__16vectorINS_14basic_raw_jsonINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_9allocatorIS8_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 2050| 30.5k| { 2051| 30.5k| constexpr auto Opts = ws_handled_off(); 2052| 30.5k| if constexpr (!check_ws_handled(Options)) { 2053| 30.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2053:17): [True: 0, False: 30.5k] ------------------ 2054| 0| return; 2055| 0| } 2056| 30.5k| } 2057| | 2058| 30.5k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2058:14): [True: 22, False: 30.5k] ------------------ 2059| 22| return; 2060| 22| } 2061| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2062| | // released at each syntactic close below 2063| 30.5k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2063:14): [True: 0, False: 30.5k] ------------------ 2064| 0| return; 2065| 0| } 2066| | 2067| 30.5k| const auto ws_start = it; 2068| 30.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2068:14): [True: 12, False: 30.5k] ------------------ 2069| 12| return; 2070| 12| } 2071| | 2072| 30.5k| if (*it == ']') { ------------------ | Branch (2072:14): [True: 21, False: 30.4k] ------------------ 2073| 21| --ctx.depth; 2074| 21| ++it; 2075| 21| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2076| 21| value.clear(); 2077| | 2078| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2079| | value.shrink_to_fit(); 2080| | } 2081| 21| } 2082| 21| return; 2083| 21| } 2084| | 2085| 30.4k| const size_t ws_size = size_t(it - ws_start); 2086| | 2087| 30.4k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2087:49): [True: 30.4k, Folded] | Branch (2087:65): [Folded, False: 0] | Branch (2087:90): [Folded, False: 0] ------------------ 2088| 30.4k| if constexpr (not should_append) { 2089| 30.4k| const auto n = value.size(); 2090| | 2091| 30.4k| auto value_it = value.begin(); 2092| | 2093| 30.4k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2093:32): [True: 0, False: 30.4k] ------------------ 2094| 0| parse::op()>(*value_it++, ctx, it, end); 2095| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2095:20): [True: 0, False: 0] ------------------ 2096| 0| return; 2097| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2097:20): [True: 0, False: 0] ------------------ 2098| 0| return; 2099| 0| } 2100| 0| if (*it == ',') { ------------------ | Branch (2100:20): [True: 0, False: 0] ------------------ 2101| 0| ++it; 2102| | 2103| 0| if constexpr (!Opts.minified && !Opts.comments) { 2104| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2104:26): [True: 0, False: 0] | Branch (2104:37): [True: 0, False: 0] ------------------ 2105| 0| skip_matching_ws(ws_start, it, ws_size); 2106| 0| } 2107| 0| } 2108| | 2109| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2109:23): [True: 0, False: 0] ------------------ 2110| 0| return; 2111| 0| } 2112| 0| } 2113| 0| else if (*it == ']') { ------------------ | Branch (2113:25): [True: 0, False: 0] ------------------ 2114| 0| --ctx.depth; 2115| 0| ++it; 2116| 0| if constexpr (erasable) { 2117| 0| value.erase(value_it, 2118| 0| value.end()); // use erase rather than resize for non-default constructible elements 2119| | 2120| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2121| | value.shrink_to_fit(); 2122| | } 2123| 0| } 2124| 0| return; 2125| 0| } 2126| 0| else [[unlikely]] { 2127| 0| ctx.error = error_code::expected_bracket; 2128| 0| return; 2129| 0| } 2130| 0| } 2131| 30.4k| } 2132| | 2133| | if constexpr (Opts.partial_read) { 2134| | // partial_read stops early on a success path, so give the level back like the 2135| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2136| | --ctx.depth; 2137| | return; 2138| | } 2139| 30.4k| else { 2140| | // growing 2141| 30.4k| if constexpr (emplace_backable || has_try_emplace_back) { 2142| 4.90M| while (it < end) { ------------------ | Branch (2142:23): [True: 4.90M, False: 0] ------------------ 2143| | // Streaming refill point: at start of each iteration, ensure buffer has data 2144| | if constexpr (has_streaming_state) { 2145| | if (ctx.stream.enabled()) { 2146| | const size_t consumed = static_cast(it - ctx.stream.data()); 2147| | const size_t remaining = ctx.stream.size() - consumed; 2148| | // Refill when less than half of buffer remains to ensure space for next element 2149| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2150| | const char* new_it; 2151| | const char* new_end; 2152| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2153| | it = new_it; 2154| | end = new_end; 2155| | if (it >= end && ctx.stream.at_eof()) { 2156| | break; // No more data, exit loop normally 2157| | } 2158| | } 2159| | } 2160| | } 2161| | 2162| | if constexpr (has_try_emplace_back) { 2163| | if (value.try_emplace_back()) 2164| | parse::op()>(value.back(), ctx, it, end); 2165| | else 2166| | ctx.error = error_code::exceeded_static_array_size; 2167| | } 2168| 4.90M| else { 2169| 4.90M| parse::op()>(value.emplace_back(), ctx, it, end); 2170| 4.90M| } 2171| | 2172| 4.90M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2172:23): [True: 4.99k, False: 4.90M] ------------------ 2173| 4.99k| return; 2174| | 2175| | // Streaming refill point: after parsing each element, refill if buffer is low 2176| | if constexpr (has_streaming_state) { 2177| | if (ctx.stream.enabled()) { 2178| | const size_t consumed = static_cast(it - ctx.stream.data()); 2179| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2180| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2181| | const char* new_it; 2182| | const char* new_end; 2183| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2184| | it = new_it; 2185| | end = new_end; 2186| | if (it >= end && ctx.stream.at_eof()) { 2187| | ctx.error = error_code::unexpected_end; 2188| | return; 2189| | } 2190| | } 2191| | } 2192| | } 2193| | 2194| 4.90M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2194:23): [True: 547, False: 4.90M] ------------------ 2195| 547| return; 2196| 547| } 2197| 4.90M| if (*it == ',') [[likely]] { ------------------ | Branch (2197:23): [True: 4.87M, False: 24.8k] ------------------ 2198| 4.87M| ++it; 2199| | 2200| 4.87M| if constexpr (!Opts.minified && !Opts.comments) { 2201| 4.87M| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2201:29): [True: 40.8k, False: 4.83M] | Branch (2201:40): [True: 40.4k, False: 396] ------------------ 2202| 40.4k| skip_matching_ws(ws_start, it, ws_size); 2203| 40.4k| } 2204| 4.87M| } 2205| | 2206| 4.87M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2206:26): [True: 48, False: 4.87M] ------------------ 2207| 48| return; 2208| 48| } 2209| 4.87M| } 2210| 24.8k| else if (*it == ']') { ------------------ | Branch (2210:28): [True: 20.5k, False: 4.29k] ------------------ 2211| 20.5k| --ctx.depth; 2212| 20.5k| ++it; 2213| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2214| | value.shrink_to_fit(); 2215| | } 2216| 20.5k| return; 2217| 20.5k| } 2218| 4.29k| else [[unlikely]] { 2219| 4.29k| ctx.error = error_code::expected_bracket; 2220| 4.29k| return; 2221| 4.29k| } 2222| 4.90M| } 2223| | 2224| | // A valid array always returns from inside the loop upon reaching ']'. 2225| | // For a null-terminated buffer the loop can only exit here by falling 2226| | // through when `it` reaches the terminator without a closing bracket, 2227| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2228| | // Non-null-terminated buffers surface this through skip_ws/depth 2229| | // tracking (or the streaming refill break), so this guard is limited 2230| | // to the null-terminated case. 2231| | if constexpr (Opts.null_terminated) { 2232| | ctx.error = error_code::unexpected_end; 2233| | } 2234| | } 2235| | else { 2236| | ctx.error = error_code::exceeded_static_array_size; 2237| | } 2238| 30.4k| } 2239| 30.4k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_14basic_raw_jsonINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 4.90M| { 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| 4.90M| else { 60| 4.90M| using V = std::remove_cvref_t; 61| 4.90M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 4.90M| end); 63| 4.90M| } 64| 4.90M| } _ZN3glz4fromILj10ENS_14basic_raw_jsonINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 1950| 4.95M| { 1951| 4.95M| auto it_start = it; 1952| 4.95M| if (*it == 'n') { ------------------ | Branch (1952:14): [True: 887, False: 4.95M] ------------------ 1953| 887| match<"null", Opts>(ctx, it, end); 1954| 887| } 1955| 4.95M| else if (is_digit(uint8_t(*it))) { ------------------ | Branch (1955:19): [True: 73.6k, False: 4.87M] ------------------ 1956| 73.6k| skip_number(ctx, it, end); 1957| 73.6k| } 1958| 4.87M| else { 1959| 4.87M| skip_value::op(ctx, it, end); 1960| 4.87M| } 1961| 4.95M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1961:14): [True: 9.46k, False: 4.94M] ------------------ 1962| 9.46k| return; 1963| 4.94M| if constexpr (string_view_t) { 1964| 4.94M| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 4.94M| static_assert(!::glz::has_streaming_state, \ | | 243| 4.94M| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 4.94M| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 4.94M| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 4.94M| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 4.94M| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 4.94M| "container), or read from a buffer that holds the whole document.") ------------------ 1965| 4.94M| } 1966| 4.94M| value.str = {it_start, static_cast(it - it_start)}; 1967| 4.94M| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_3rpc18request_envelope_tETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 315k| { 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| 315k| else { 60| 315k| using V = std::remove_cvref_t; 61| 315k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 315k| end); 63| 315k| } 64| 315k| } _ZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 2791| 315k| { 2792| 315k| static constexpr auto num_members = reflect::size; 2793| | 2794| 315k| static constexpr auto Opts = opening_handled_off()>(); 2795| 315k| if constexpr (!check_opening_handled(Options)) { 2796| 315k| if constexpr (!check_ws_handled(Options)) { 2797| 315k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2797:20): [True: 14, False: 315k] ------------------ 2798| 14| return; 2799| 14| } 2800| 315k| } 2801| 315k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (2801:17): [True: 161k, False: 154k] ------------------ 2802| 161k| return; 2803| 161k| } 2804| 154k| if constexpr (not Opts.null_terminated) { 2805| 154k| if (it == end) [[unlikely]] { ------------------ | Branch (2805:20): [True: 0, False: 154k] ------------------ 2806| 0| ctx.error = error_code::unexpected_end; 2807| 0| return; 2808| 0| } 2809| 154k| } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| 154k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2812:17): [True: 0, False: 154k] ------------------ 2813| 0| return; 2814| 0| } 2815| 154k| } 2816| 154k| const auto ws_start = it; 2817| 315k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 15, False: 315k] ------------------ 2818| 15| return; 2819| 15| } 2820| 315k| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 315k| else { 2895| 315k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 315k| if constexpr ((glaze_object_t || reflectable) && 2897| 315k| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 315k| return bit_array{}; 2899| 315k| } 2900| 315k| else { 2901| 315k| return nullptr; 2902| 315k| } 2903| 315k| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 315k| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 315k| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 315k| return has_includer_member; 2915| 315k| } 2916| 315k| else { 2917| 315k| return false; 2918| 315k| } 2919| 315k| }(); 2920| 315k| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 315k| [[maybe_unused]] const std::conditional_t>, 2930| 315k| inert_key_bits_scope> published_bits{ 2931| 315k| ctx, [&]() -> void* { 2932| 315k| if constexpr (tracks_include_keys) { 2933| 315k| return &fields; 2934| 315k| } 2935| 315k| else { 2936| 315k| return nullptr; 2937| 315k| } 2938| 315k| }()}; 2939| | 2940| 315k| size_t read_count{}; // for partial_read 2941| | 2942| 315k| bool first = true; 2943| 637k| while (true) { ------------------ | Branch (2943:20): [True: 393k, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 393k| if (*it == '}') { ------------------ | Branch (2980:20): [True: 62.5k, False: 331k] ------------------ 2981| 62.5k| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| 62.5k| if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| 62.5k| } 3017| 62.5k| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 62.5k| if constexpr (not Opts.null_terminated) { 3019| 62.5k| if (it == end) { ------------------ | Branch (3019:26): [True: 57.5k, False: 4.98k] ------------------ 3020| 57.5k| ctx.error = error_code::end_reached; 3021| 57.5k| return; 3022| 57.5k| } 3023| 62.5k| } 3024| 4.98k| return; 3025| 62.5k| } 3026| 331k| else if (first) { ------------------ | Branch (3026:25): [True: 152k, False: 178k] ------------------ 3027| 152k| first = false; 3028| 152k| } 3029| 178k| else { 3030| 178k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 8.41k, False: 169k] ------------------ 3031| 8.41k| return; 3032| 8.41k| } 3033| 169k| if constexpr (not Opts.null_terminated) { 3034| 169k| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 169k] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 169k| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| 169k| (!Opts.comments)) { 3042| 169k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3042:26): [True: 11.0k, False: 158k] | Branch (3042:37): [True: 9.73k, False: 1.30k] ------------------ 3043| 9.73k| skip_matching_ws(ws_start, it, ws_size); 3044| 9.73k| } 3045| 169k| } 3046| | 3047| 169k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 3, False: 169k] ------------------ 3048| 3| return; 3049| 3| } 3050| 169k| } 3051| | 3052| 322k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [True: 322k, Folded] | Branch (3052:70): [Folded, False: 0] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| 322k| else if constexpr (reflection_type) { 3118| 322k| static_assert(bool(hash_info.type)); 3119| | 3120| 322k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3120:23): [True: 16.8k, False: 305k] ------------------ 3121| 16.8k| ctx.error = error_code::expected_quote; 3122| 16.8k| return; 3123| 16.8k| } 3124| 305k| ++it; 3125| 305k| if constexpr (not Opts.null_terminated) { 3126| 305k| if (it == end) [[unlikely]] { ------------------ | Branch (3126:26): [True: 4, False: 305k] ------------------ 3127| 4| ctx.error = error_code::unexpected_end; 3128| 4| return; 3129| 4| } 3130| 305k| } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| 305k| else { 3181| 305k| parse_and_invoke(value, ctx, it, end); 3182| 305k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3182:26): [True: 66.1k, False: 239k] ------------------ 3183| 66.1k| return; 3184| 305k| } 3185| | } 3186| | else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| | auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| | else { 3200| | parse::op()>(value[key], ctx, it, end); 3201| | } 3202| | }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| | using Key = typename T::key_type; 3206| | if constexpr (std::is_same_v) { 3207| | ctx.scratch.clear(); 3208| | parse::op(ctx.scratch, ctx, it, end); 3209| | if (bool(ctx.error)) [[unlikely]] 3210| | return; 3211| | 3212| | if (parse_ws_colon(ctx, it, end)) { 3213| | return; 3214| | } 3215| | 3216| | reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| | if (bool(ctx.error)) [[unlikely]] 3223| | return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| | } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 322k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 276, False: 322k] ------------------ 3294| 276| return; 3295| 276| } 3296| 322k| } 3297| 315k| } 3298| 315k| } _ZZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 154k| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 154k| else { 2901| 154k| return nullptr; 2902| 154k| } 2903| 154k| }(); _ZZN3glz4fromILj10ENS_3rpc18request_envelope_tEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 154k| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 154k| else { 2936| 154k| return nullptr; 2937| 154k| } 2938| 154k| }()}; _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 382| 305k| { 383| 305k| constexpr auto N = reflect::size; 384| | 385| | if constexpr (N == 1) { 386| | decode_index(value, ctx, it, end, selected_index...); 387| | } 388| | else if constexpr (check_linear_search(Opts)) { 389| | // Linear search path 390| | auto key_start = it; 391| | const auto index = decode_linear(ctx, it, end); 392| | if (bool(ctx.error)) [[unlikely]] 393| | return; 394| | 395| | if (index >= N) [[unlikely]] { 396| | if constexpr (Opts.error_on_unknown_keys) { 397| | ctx.error = error_code::unknown_key; 398| | return; 399| | } 400| | else { 401| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 402| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 403| | return; 404| | } 405| | const sv key{key_start, size_t(it - key_start - 1)}; 406| | if constexpr (not Opts.null_terminated) { 407| | if (it == end) [[unlikely]] { 408| | ctx.error = error_code::unexpected_end; 409| | return; 410| | } 411| | } 412| | if (parse_ws_colon(ctx, it, end)) { 413| | return; 414| | } 415| | parse::handle_unknown(key, value, ctx, it, end); 416| | return; 417| | } 418| | } 419| | 420| | if constexpr (not Opts.null_terminated) { 421| | if (it == end) [[unlikely]] { 422| | ctx.error = error_code::unexpected_end; 423| | return; 424| | } 425| | } 426| | if (skip_ws(ctx, it, end)) { 427| | return; 428| | } 429| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 430| | return; 431| | } 432| | if (skip_ws(ctx, it, end)) { 433| | return; 434| | } 435| | 436| | // Fold expression dispatch - avoids jump table overhead for smaller binary size. 437| | // For linear_search, pass Opts through to the field parser to avoid duplicate template 438| | // instantiations; the whitespace before the value has already been skipped either way. 439| | [&](std::index_sequence) { 440| | (void)(((index == Is ? (decode_field_value(value, ctx, it, end, selected_index...), true) 441| | : false) || 442| | ...)); 443| | }(std::make_index_sequence{}); 444| | } 445| 305k| else { 446| | // Hash-based lookup 447| 305k| constexpr auto& HashInfo = hash_info; 448| 305k| constexpr auto type = HashInfo.type; 449| 305k| static_assert(bool(type), "invalid hash algorithm"); 450| | 451| 305k| const auto index = decode_hash::op(it, end); 452| | 453| 305k| if (index >= N) [[unlikely]] { ------------------ | Branch (453:14): [True: 27.7k, False: 278k] ------------------ 454| 27.7k| if constexpr (Opts.error_on_unknown_keys) { 455| 27.7k| ctx.error = error_code::unknown_key; 456| 27.7k| return; 457| | } 458| | else { 459| | auto start = it; 460| | skip_string_view(ctx, it, end); 461| | if (bool(ctx.error)) [[unlikely]] 462| | return; 463| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 464| | return; 465| | const sv key = {start, size_t(it - start)}; 466| | ++it; // skip the quote 467| | if constexpr (not Opts.null_terminated) { 468| | if (it == end) [[unlikely]] { 469| | ctx.error = error_code::unexpected_end; 470| | return; 471| | } 472| | } 473| | if (parse_ws_colon(ctx, it, end)) { 474| | return; 475| | } 476| | parse::handle_unknown(key, value, ctx, it, end); 477| | return; 478| | } 479| 27.7k| } 480| | 481| | if constexpr (N == 2) { 482| | if (index == 0) { 483| | decode_index(value, ctx, it, end, selected_index...); 484| | } 485| | else { 486| | decode_index(value, ctx, it, end, selected_index...); 487| | } 488| | } 489| 305k| else { 490| 305k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 491| 305k| } 492| 305k| } 493| 305k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav: 490| 75.9k| 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_: 312| 75.9k| { 313| 75.9k| static constexpr auto Key = get(reflect::keys); 314| 75.9k| static constexpr auto KeyWithEndQuote = join_v>; 315| 75.9k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 75.9k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 75.2k, False: 669] | Branch (321:52): [True: 73.8k, False: 1.35k] ------------------ 322| 73.8k| it += Length; 323| 73.8k| if constexpr (not Opts.null_terminated) { 324| 73.8k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 73.8k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 73.8k| } 329| | 330| 73.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 2, False: 73.8k] ------------------ 331| 2| return; 332| 2| } 333| 73.8k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 1.05k, False: 72.8k] ------------------ 334| 1.05k| return; 335| 1.05k| } 336| 72.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 2, False: 72.8k] ------------------ 337| 2| return; 338| 2| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 72.8k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 72.8k| } 343| 2.02k| else [[unlikely]] { 344| 2.02k| decode_index_unknown_key(value, ctx, it, end); 345| 2.02k| } 346| 75.9k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 72.8k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 72.8k| else { 274| 72.8k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| 72.8k| else if constexpr (glaze_object_t) { 294| 72.8k| from>::template op(get_member(value, get(reflect::values)), 295| 72.8k| ctx, it, end); 296| | } 297| | else { 298| | from>::template op(get_member(value, get(to_tie(value))), ctx, 299| | it, end); 300| | } 301| 72.8k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 72.8k| } _ZN3glz4fromILj10ENSt3__18optionalINS1_17basic_string_viewIcNS1_11char_traitsIcEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 4883| 137k| { 4884| 137k| constexpr auto Opts = ws_handled_off(); 4885| | if constexpr (!check_ws_handled(Options)) { 4886| | if (skip_ws(ctx, it, end)) { 4887| | return; 4888| | } 4889| | } 4890| | 4891| 137k| if (*it == 'n') { ------------------ | Branch (4891:14): [True: 1.09k, False: 135k] ------------------ 4892| 1.09k| ++it; 4893| 1.09k| if constexpr (not Opts.null_terminated) { 4894| 1.09k| if (it == end) [[unlikely]] { ------------------ | Branch (4894:20): [True: 1, False: 1.09k] ------------------ 4895| 1| ctx.error = error_code::unexpected_end; 4896| 1| return; 4897| 1| } 4898| 1.09k| } 4899| 1.09k| match<"ull", Opts>(ctx, it, end); 4900| 1.09k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (4900:17): [True: 676, False: 420] ------------------ 4901| 676| return; 4902| 420| if constexpr (requires { value.reset(); }) { 4903| 420| value.reset(); 4904| 420| } 4905| 420| } 4906| 135k| else { 4907| 135k| if constexpr (nullable_value_t) { 4908| 135k| if (not value.has_value()) { ------------------ | Branch (4908:20): [True: 133k, False: 2.02k] ------------------ 4909| | if constexpr (constructible) { 4910| | value = meta_construct_v(); 4911| | } 4912| 133k| else if constexpr (requires { value.emplace(); }) { 4913| 133k| value.emplace(); 4914| | } 4915| | else { 4916| | static_assert(false_v, 4917| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 4918| | "create a custom glz::from specialization"); 4919| | } 4920| 133k| } 4921| 135k| parse::op(value.value(), ctx, it, end); 4922| | } 4923| | else { 4924| | if (!value) { 4925| | if (!nullable_emplace(value, ctx)) { 4926| | return; 4927| | } 4928| | } 4929| | parse::op(*value, ctx, it, end); 4930| | } 4931| 135k| } 4932| 137k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 135k| { 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| 135k| else { 60| 135k| using V = std::remove_cvref_t; 61| 135k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 135k| end); 63| 135k| } 64| 135k| } _ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_: 1606| 135k| { 1607| 135k| if constexpr (!check_opening_handled(Opts)) { 1608| 135k| if constexpr (!check_ws_handled(Opts)) { 1609| 135k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (1609:20): [True: 0, False: 135k] ------------------ 1610| 0| return; 1611| 0| } 1612| 135k| } 1613| | 1614| 135k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1614:17): [True: 1.03k, False: 134k] ------------------ 1615| 1.03k| return; 1616| 1.03k| } 1617| 135k| } 1618| | 1619| 134k| auto start = it; 1620| 135k| skip_string_view(ctx, it, end); 1621| 135k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1621:14): [True: 12, False: 135k] ------------------ 1622| 12| return; 1623| | 1624| 135k| if (validate_utf8_span(ctx, start, it)) [[unlikely]] { ------------------ | Branch (1624:14): [True: 37, False: 135k] ------------------ 1625| 37| return; 1626| 37| } 1627| | 1628| 135k| if constexpr (string_view_t) { 1629| 135k| if constexpr (!Transient) { 1630| 135k| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 135k| static_assert(!::glz::has_streaming_state, \ | | 243| 135k| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 135k| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 135k| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 135k| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 135k| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 135k| "container), or read from a buffer that holds the whole document.") ------------------ 1631| 135k| } 1632| 135k| using value_type = typename std::decay_t::value_type; 1633| | if constexpr (std::same_as) { 1634| | value = {reinterpret_cast(start), size_t(it - start)}; 1635| | } 1636| 135k| else { 1637| 135k| value = {start, size_t(it - start)}; 1638| 135k| } 1639| | } 1640| | else if constexpr (char_array_t) { 1641| | const size_t n = it - start; 1642| | if ((n + 1) > sizeof(value)) { 1643| | ctx.error = error_code::unexpected_end; 1644| | return; 1645| | } 1646| | std::memcpy(value, start, n); 1647| | value[n] = '\0'; 1648| | } 1649| | else if constexpr (array_char_t) { 1650| | const size_t n = it - start; 1651| | if ((n + 1) > value.size()) { 1652| | ctx.error = error_code::unexpected_end; 1653| | return; 1654| | } 1655| | std::memcpy(value.data(), start, n); 1656| | value[n] = '\0'; 1657| | } 1658| | else if constexpr (static_string_t) { 1659| | const size_t n = it - start; 1660| | if (n > value.capacity()) { 1661| | ctx.error = error_code::unexpected_end; 1662| | return; 1663| | } 1664| | value.assign(start, n); 1665| | } 1666| 135k| ++it; // skip closing quote 1667| 135k| if constexpr (not Opts.null_terminated) { 1668| 135k| if (it == end) { ------------------ | Branch (1668:17): [True: 7, False: 135k] ------------------ 1669| 7| ctx.error = error_code::end_reached; 1670| 7| return; 1671| 7| } 1672| 135k| } 1673| 135k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 9.26k| { 178| 9.26k| if constexpr (Opts.error_on_unknown_keys) { 179| 9.26k| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | uint64_t ascii_acc{}; 184| | skip_string_view(ctx, it, end, ascii_acc); 185| | if (bool(ctx.error)) [[unlikely]] 186| | return; 187| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 188| | return; 189| | const sv key = {start, size_t(it - start)}; 190| | ++it; 191| | if constexpr (not Opts.null_terminated) { 192| | if (it == end) [[unlikely]] { 193| | ctx.error = error_code::unexpected_end; 194| | return; 195| | } 196| | } 197| | 198| | if (parse_ws_colon(ctx, it, end)) { 199| | return; 200| | } 201| | 202| | parse::handle_unknown(key, value, ctx, it, end); 203| | } 204| 9.26k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav: 490| 65.9k| 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_: 312| 65.9k| { 313| 65.9k| static constexpr auto Key = get(reflect::keys); 314| 65.9k| static constexpr auto KeyWithEndQuote = join_v>; 315| 65.9k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 65.9k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 65.1k, False: 702] | Branch (321:52): [True: 64.2k, False: 951] ------------------ 322| 64.2k| it += Length; 323| 64.2k| if constexpr (not Opts.null_terminated) { 324| 64.2k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 64.2k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 64.2k| } 329| | 330| 64.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 64.2k] ------------------ 331| 0| return; 332| 0| } 333| 64.2k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 0, False: 64.2k] ------------------ 334| 0| return; 335| 0| } 336| 64.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 64.2k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 64.2k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 64.2k| } 343| 1.65k| else [[unlikely]] { 344| 1.65k| decode_index_unknown_key(value, ctx, it, end); 345| 1.65k| } 346| 65.9k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 64.2k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 64.2k| else { 274| 64.2k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| 64.2k| else if constexpr (glaze_object_t) { 294| 64.2k| from>::template op(get_member(value, get(reflect::values)), 295| 64.2k| ctx, it, end); 296| | } 297| | else { 298| | from>::template op(get_member(value, get(to_tie(value))), ctx, 299| | it, end); 300| | } 301| 64.2k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 64.2k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav: 490| 46.9k| 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_: 312| 46.9k| { 313| 46.9k| static constexpr auto Key = get(reflect::keys); 314| 46.9k| static constexpr auto KeyWithEndQuote = join_v>; 315| 46.9k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 46.9k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 46.5k, False: 347] | Branch (321:52): [True: 46.0k, False: 552] ------------------ 322| 46.0k| it += Length; 323| 46.0k| if constexpr (not Opts.null_terminated) { 324| 46.0k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 46.0k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 46.0k| } 329| | 330| 46.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 0, False: 46.0k] ------------------ 331| 0| return; 332| 0| } 333| 46.0k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 0, False: 46.0k] ------------------ 334| 0| return; 335| 0| } 336| 46.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 0, False: 46.0k] ------------------ 337| 0| return; 338| 0| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 46.0k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 46.0k| } 343| 899| else [[unlikely]] { 344| 899| decode_index_unknown_key(value, ctx, it, end); 345| 899| } 346| 46.9k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 46.0k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 46.0k| else { 274| 46.0k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| 46.0k| else if constexpr (glaze_object_t) { 294| 46.0k| from>::template op(get_member(value, get(reflect::values)), 295| 46.0k| ctx, it, end); 296| | } 297| | else { 298| | from>::template op(get_member(value, get(to_tie(value))), ctx, 299| | it, end); 300| | } 301| 46.0k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 46.0k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav: 490| 89.3k| 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_: 312| 89.3k| { 313| 89.3k| static constexpr auto Key = get(reflect::keys); 314| 89.3k| static constexpr auto KeyWithEndQuote = join_v>; 315| 89.3k| static constexpr auto Length = KeyWithEndQuote.size(); 316| | 317| | // Compared as a count rather than by forming `it + Length` first: a pointer past one-past-the-end 318| | // is undefined even when it is never dereferenced, and a key near the end of a short buffer 319| | // reaches this with fewer than `Length` bytes left. Signed, so a cursor that has overshot 320| | // `end` does not read as room. 321| 89.3k| if (((end - it) > std::ptrdiff_t(Length)) && comparitor(it)) [[likely]] { ------------------ | Branch (321:11): [True: 89.1k, False: 203] | Branch (321:52): [True: 84.6k, False: 4.48k] ------------------ 322| 84.6k| it += Length; 323| 84.6k| if constexpr (not Opts.null_terminated) { 324| 84.6k| if (it == end) [[unlikely]] { ------------------ | Branch (324:17): [True: 0, False: 84.6k] ------------------ 325| 0| ctx.error = error_code::unexpected_end; 326| 0| return; 327| 0| } 328| 84.6k| } 329| | 330| 84.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (330:14): [True: 2, False: 84.6k] ------------------ 331| 2| return; 332| 2| } 333| 84.6k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (333:14): [True: 976, False: 83.6k] ------------------ 334| 976| return; 335| 976| } 336| 83.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (336:14): [True: 3, False: 83.6k] ------------------ 337| 3| return; 338| 3| } 339| | 340| | // The hash path has already consumed the whitespace before the value 341| 83.6k| decode_field_value(), T, I>(value, ctx, it, end, selected_index...); 342| 83.6k| } 343| 4.69k| else [[unlikely]] { 344| 4.69k| decode_index_unknown_key(value, ctx, it, end); 345| 4.69k| } 346| 89.3k| } _ZN3glz18decode_field_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnDaXtlS1_Lj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEENS_3rpc18request_envelope_tELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT1_E11reflectableISA_EEEvOT3_OT5_OT6_OT7_DpOT4_: 246| 83.6k| { 247| | // Check for null value skipping on read 248| | if constexpr (check_skip_null_members_on_read(Opts)) { 249| | if (*it == 'n') { 250| | ++it; 251| | if constexpr (not Opts.null_terminated) { 252| | if (it == end) [[unlikely]] { 253| | ctx.error = error_code::unexpected_end; 254| | return; 255| | } 256| | } 257| | match<"ull", Opts>(ctx, it, end); 258| | if (bool(ctx.error)) [[unlikely]] 259| | return; 260| | // Successfully matched "null", skip it 261| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 262| | ((selected_index = I), ...); // Mark as handled even if skipped 263| | } 264| | return; 265| | } 266| | } 267| | 268| | if constexpr (skipped_by_meta) { 269| | skip_value::op(ctx, it, end); 270| | if (bool(ctx.error)) [[unlikely]] 271| | return; // Propagate error from skip_value 272| | } 273| 83.6k| else { 274| 83.6k| using V = refl_t; 275| | 276| | if constexpr (const_value_v) { 277| | if constexpr (check_error_on_const_read(Opts)) { 278| | ctx.error = error_code::attempt_const_read; 279| | } 280| | else { 281| | // do not read anything into the const value 282| | skip_value::op(ctx, it, end); 283| | } 284| | } 285| | else if constexpr (is_function_ptr_or_ref) { 286| | // Function pointers cannot be deserialized from JSON. 287| | // When write_function_pointers is enabled the writer emits a type-name string, 288| | // but there is nothing meaningful to reconstruct on read — just skip the value. 289| | // When write_function_pointers is off the key is never written, so this branch 290| | // is unreachable in that case. 291| | skip_value::op(ctx, it, end); 292| | } 293| 83.6k| else if constexpr (glaze_object_t) { 294| 83.6k| from>::template op(get_member(value, get(reflect::values)), 295| 83.6k| ctx, it, end); 296| | } 297| | else { 298| | from>::template op(get_member(value, get(to_tie(value))), ctx, 299| | it, end); 300| | } 301| 83.6k| } 302| | 303| | // The key was present and handled, even when the value itself was skipped 304| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 305| | ((selected_index = I), ...); 306| | } 307| 83.6k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 3860| 83.6k| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 83.6k| else { 3865| 83.6k| read_deduced(value, ctx, it, end); 3866| 83.6k| } 3867| 83.6k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 3871| 83.6k| { 3872| 83.6k| constexpr auto Opts = ws_handled_off(); 3873| 83.6k| if constexpr (variant_is_auto_deducible()) { 3874| | if constexpr (not check_ws_handled(Options)) { 3875| | if (skip_ws(ctx, it, end)) { 3876| | return; 3877| | } 3878| | } 3879| | 3880| 83.6k| switch (*it) { 3881| 257| case '\0': ------------------ | Branch (3881:13): [True: 257, False: 83.3k] ------------------ 3882| 257| ctx.error = error_code::unexpected_end; 3883| 257| return; 3884| 4.42k| case '{': { ------------------ | Branch (3884:13): [True: 4.42k, False: 79.2k] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 4.42k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 4.42k] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 4.42k| ++it; 3894| 4.42k| if constexpr (not Opts.null_terminated) { 3895| 4.42k| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 1, False: 4.42k] ------------------ 3896| 1| ctx.error = error_code::unexpected_end; 3897| 1| return; 3898| 1| } 3899| 4.42k| } 3900| 4.42k| using type_counts = variant_type_count; 3901| 4.42k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| 4.42k| if constexpr (n_object_candidates < 1) { 3903| 4.42k| ctx.error = error_code::no_matching_variant_type; 3904| 4.42k| return; 3905| | } 3906| | else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| | constexpr auto first_idx = variant_first_object_candidate_v; 3908| | using V = std::variant_alternative_t; 3909| | if (!std::holds_alternative(value)) value = V{}; 3910| | parse::op()>(std::get(value), ctx, it, end); 3911| | return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 4.42k| } 4596| 4.17k| case '[': ------------------ | Branch (4596:13): [True: 4.17k, False: 79.4k] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 4.17k| process_variant_alternatives::template op(value, ctx, it, end); 4599| 4.17k| break; 4600| 6.15k| case '"': { ------------------ | Branch (4600:13): [True: 6.15k, False: 77.4k] ------------------ 4601| 6.15k| process_variant_alternatives::template op(value, ctx, it, end); 4602| 6.15k| break; 4603| 4.42k| } 4604| 567| case 't': ------------------ | Branch (4604:13): [True: 567, False: 83.0k] ------------------ 4605| 997| case 'f': { ------------------ | Branch (4605:13): [True: 430, False: 83.2k] ------------------ 4606| 997| process_variant_alternatives::template op(value, ctx, it, end); 4607| 997| break; 4608| 567| } 4609| 1.27k| case 'n': ------------------ | Branch (4609:13): [True: 1.27k, False: 82.3k] ------------------ 4610| | if constexpr (variant_count_v == 0) { 4611| | ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| 1.27k| else { 4614| 1.27k| constexpr auto first_idx = variant_first_index_v; 4615| 1.27k| using V = std::variant_alternative_t; 4616| 1.27k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4616:23): [True: 195, False: 1.08k] ------------------ 4617| 1.27k| match<"null", Opts>(ctx, it, end); 4618| 1.27k| } 4619| 1.27k| break; 4620| 66.3k| default: { ------------------ | Branch (4620:13): [True: 66.3k, False: 17.2k] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 66.3k| process_variant_alternatives::template op(value, ctx, it, end); 4623| 66.3k| } 4624| 83.6k| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 83.6k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3520| 7.12k| { 3521| 7.12k| constexpr auto category_count = variant_count_v; 3522| | 3523| 7.12k| if constexpr (category_count == 0) { 3524| 7.12k| ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| | else { 3527| | constexpr auto N = std::variant_size_v; 3528| | constexpr auto const_count = variant_filtered_count_v; 3529| | constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| | bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| | bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| | if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| | size_t non_const_idx = 0; 3588| | 3589| | for_each([&]() { 3590| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| | return; 3592| | } 3593| | using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| | }); 3645| | if (!found_match) { 3646| | if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| | } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| | } 3659| 7.12k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3520| 9.07k| { 3521| 9.07k| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 9.07k| else { 3527| 9.07k| constexpr auto N = std::variant_size_v; 3528| 9.07k| constexpr auto const_count = variant_filtered_count_v; 3529| 9.07k| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 9.07k| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 9.07k| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 9.07k| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 9.07k| size_t non_const_idx = 0; 3588| | 3589| 9.07k| for_each([&]() { 3590| 9.07k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 9.07k| return; 3592| 9.07k| } 3593| 9.07k| using V = std::variant_alternative_t; 3594| 9.07k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 9.07k| auto copy_it{it}; 3596| 9.07k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 9.07k| if (!std::holds_alternative(value)) { 3598| 9.07k| value = V{}; 3599| 9.07k| } 3600| 9.07k| parse::op()>(std::get(value), ctx, it, end); 3601| 9.07k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 9.07k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 9.07k| } 3604| 9.07k| if (!bool(ctx.error)) { 3605| 9.07k| found_match = true; 3606| 9.07k| } 3607| 9.07k| else if constexpr (not Options.null_terminated) { 3608| 9.07k| constexpr bool is_complete_type = 3609| 9.07k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 9.07k| if constexpr (is_complete_type) { 3612| 9.07k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 9.07k| found_match = true; 3614| 9.07k| ctx.error = error_code::none; 3615| 9.07k| } 3616| 9.07k| else { 3617| 9.07k| it = copy_it; 3618| 9.07k| rewind_depth(ctx, copy_depth); 3619| 9.07k| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 9.07k| not variant_alternative_exhausted(ctx)) { 3621| 9.07k| ctx.error = error_code::none; 3622| 9.07k| } 3623| 9.07k| } 3624| 9.07k| } 3625| 9.07k| else { 3626| 9.07k| it = copy_it; 3627| 9.07k| rewind_depth(ctx, copy_depth); 3628| 9.07k| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 9.07k| not variant_alternative_exhausted(ctx)) { 3630| 9.07k| ctx.error = error_code::none; 3631| 9.07k| } 3632| 9.07k| } 3633| 9.07k| } 3634| 9.07k| else { 3635| 9.07k| it = copy_it; 3636| 9.07k| rewind_depth(ctx, copy_depth); 3637| 9.07k| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 9.07k| not variant_alternative_exhausted(ctx)) { 3639| 9.07k| ctx.error = error_code::none; 3640| 9.07k| } 3641| 9.07k| } 3642| 9.07k| ++non_const_idx; 3643| 9.07k| } 3644| 9.07k| }); 3645| 9.07k| if (!found_match) { ------------------ | Branch (3645:20): [True: 3.01k, False: 6.05k] ------------------ 3646| 3.01k| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 3.01k| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 9.07k| } 3659| 9.07k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3589| 9.07k| for_each([&]() { 3590| 9.07k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 9.07k] | Branch (3590:38): [True: 0, False: 9.07k] | Branch (3590:51): [True: 0, False: 9.07k] ------------------ 3591| 0| return; 3592| 0| } 3593| 9.07k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 9.07k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3589| 9.07k| for_each([&]() { 3590| 9.07k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 9.07k] | Branch (3590:38): [True: 0, False: 9.07k] | Branch (3590:51): [True: 0, False: 9.07k] ------------------ 3591| 0| return; 3592| 0| } 3593| 9.07k| using V = std::variant_alternative_t; 3594| 9.07k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 9.07k| auto copy_it{it}; 3596| 9.07k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 9.07k| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 8.72k, False: 350] ------------------ 3598| 8.72k| value = V{}; 3599| 8.72k| } 3600| 9.07k| parse::op()>(std::get(value), ctx, it, end); 3601| 9.07k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 3.01k, False: 6.05k] | Branch (3601:45): [True: 0, False: 3.01k] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 9.07k| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 6.05k, False: 3.01k] ------------------ 3605| 6.05k| found_match = true; 3606| 6.05k| } 3607| 3.01k| else if constexpr (not Options.null_terminated) { 3608| 3.01k| constexpr bool is_complete_type = 3609| 3.01k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [Folded, False: 0] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [Folded, False: 0] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| 3.01k| else { 3626| 3.01k| it = copy_it; 3627| 3.01k| rewind_depth(ctx, copy_depth); 3628| 3.01k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3628:32): [True: 0, False: 3.01k] | Branch (3628:71): [True: 0, False: 0] ------------------ 3629| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3629:32): [True: 0, False: 0] ------------------ 3630| 0| ctx.error = error_code::none; 3631| 0| } 3632| 3.01k| } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 9.07k| ++non_const_idx; 3643| 9.07k| } 3644| 9.07k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 9.07k| { 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| 9.07k| else { 60| 9.07k| using V = std::remove_cvref_t; 61| 9.07k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 9.07k| end); 63| 9.07k| } 64| 9.07k| } _ZN3glz4fromILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEELb0ERPKcSA_S5_TkNS_10is_contextERNS_7contextEQntcl22check_string_as_numberTL0__EEEvRT3_OT4_OT1_T2_: 1606| 9.07k| { 1607| 9.07k| if constexpr (!check_opening_handled(Opts)) { 1608| | if constexpr (!check_ws_handled(Opts)) { 1609| | if (skip_ws(ctx, it, end)) { 1610| | return; 1611| | } 1612| | } 1613| | 1614| 9.07k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1614:17): [True: 2, False: 9.06k] ------------------ 1615| 2| return; 1616| 2| } 1617| 9.07k| } 1618| | 1619| 9.06k| auto start = it; 1620| 9.07k| skip_string_view(ctx, it, end); 1621| 9.07k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (1621:14): [True: 14, False: 9.05k] ------------------ 1622| 14| return; 1623| | 1624| 9.05k| if (validate_utf8_span(ctx, start, it)) [[unlikely]] { ------------------ | Branch (1624:14): [True: 77, False: 8.98k] ------------------ 1625| 77| return; 1626| 77| } 1627| | 1628| 8.98k| if constexpr (string_view_t) { 1629| 8.98k| if constexpr (!Transient) { 1630| 8.98k| GLZ_ASSERT_OWNS_ITS_BYTES(decltype(ctx)); ------------------ | | 242| 8.98k| static_assert(!::glz::has_streaming_state, \ | | 243| 8.98k| "This read fills a non-owning view (std::string_view, glz::raw_json_view, glz::text_view, or " \ | | 244| 8.98k| "a std::span) that would point into the streaming window. A streaming read refills that " \ | | 245| 8.98k| "window as it goes, so the view would address overwritten bytes by the time the read " \ | | 246| 8.98k| "returns, and the read would report success while handing back silently wrong data. Read " \ | | 247| 8.98k| "into the owning equivalent instead (std::string, glz::raw_json, glz::text, or an owning " \ | | 248| 8.98k| "container), or read from a buffer that holds the whole document.") ------------------ 1631| 8.98k| } 1632| 8.98k| using value_type = typename std::decay_t::value_type; 1633| | if constexpr (std::same_as) { 1634| | value = {reinterpret_cast(start), size_t(it - start)}; 1635| | } 1636| 8.98k| else { 1637| 8.98k| value = {start, size_t(it - start)}; 1638| 8.98k| } 1639| | } 1640| | else if constexpr (char_array_t) { 1641| | const size_t n = it - start; 1642| | if ((n + 1) > sizeof(value)) { 1643| | ctx.error = error_code::unexpected_end; 1644| | return; 1645| | } 1646| | std::memcpy(value, start, n); 1647| | value[n] = '\0'; 1648| | } 1649| | else if constexpr (array_char_t) { 1650| | const size_t n = it - start; 1651| | if ((n + 1) > value.size()) { 1652| | ctx.error = error_code::unexpected_end; 1653| | return; 1654| | } 1655| | std::memcpy(value.data(), start, n); 1656| | value[n] = '\0'; 1657| | } 1658| | else if constexpr (static_string_t) { 1659| | const size_t n = it - start; 1660| | if (n > value.capacity()) { 1661| | ctx.error = error_code::unexpected_end; 1662| | return; 1663| | } 1664| | value.assign(start, n); 1665| | } 1666| 8.98k| ++it; // skip closing quote 1667| 8.98k| if constexpr (not Opts.null_terminated) { 1668| 8.98k| if (it == end) { ------------------ | Branch (1668:17): [True: 2.92k, False: 6.05k] ------------------ 1669| 2.92k| ctx.error = error_code::end_reached; 1670| 2.92k| return; 1671| 2.92k| } 1672| 8.98k| } 1673| 8.98k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3589| 9.07k| for_each([&]() { 3590| 9.07k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 6.05k, False: 3.01k] | Branch (3590:38): [True: 0, False: 3.01k] | Branch (3590:51): [True: 0, False: 3.01k] ------------------ 3591| 6.05k| return; 3592| 6.05k| } 3593| 3.01k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 3.01k| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3520| 1.51k| { 3521| 1.51k| constexpr auto category_count = variant_count_v; 3522| | 3523| 1.51k| if constexpr (category_count == 0) { 3524| 1.51k| ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| | else { 3527| | constexpr auto N = std::variant_size_v; 3528| | constexpr auto const_count = variant_filtered_count_v; 3529| | constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| | bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| | bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| | if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| | size_t non_const_idx = 0; 3588| | 3589| | for_each([&]() { 3590| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| | return; 3592| | } 3593| | using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| | }); 3645| | if (!found_match) { 3646| | if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| | } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| | } 3659| 1.51k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_: 3520| 76.4k| { 3521| 76.4k| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 76.4k| else { 3527| 76.4k| constexpr auto N = std::variant_size_v; 3528| 76.4k| constexpr auto const_count = variant_filtered_count_v; 3529| 76.4k| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 76.4k| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 76.4k| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 76.4k| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 76.4k| size_t non_const_idx = 0; 3588| | 3589| 76.4k| for_each([&]() { 3590| 76.4k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 76.4k| return; 3592| 76.4k| } 3593| 76.4k| using V = std::variant_alternative_t; 3594| 76.4k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 76.4k| auto copy_it{it}; 3596| 76.4k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 76.4k| if (!std::holds_alternative(value)) { 3598| 76.4k| value = V{}; 3599| 76.4k| } 3600| 76.4k| parse::op()>(std::get(value), ctx, it, end); 3601| 76.4k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 76.4k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 76.4k| } 3604| 76.4k| if (!bool(ctx.error)) { 3605| 76.4k| found_match = true; 3606| 76.4k| } 3607| 76.4k| else if constexpr (not Options.null_terminated) { 3608| 76.4k| constexpr bool is_complete_type = 3609| 76.4k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 76.4k| if constexpr (is_complete_type) { 3612| 76.4k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 76.4k| found_match = true; 3614| 76.4k| ctx.error = error_code::none; 3615| 76.4k| } 3616| 76.4k| else { 3617| 76.4k| it = copy_it; 3618| 76.4k| rewind_depth(ctx, copy_depth); 3619| 76.4k| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 76.4k| not variant_alternative_exhausted(ctx)) { 3621| 76.4k| ctx.error = error_code::none; 3622| 76.4k| } 3623| 76.4k| } 3624| 76.4k| } 3625| 76.4k| else { 3626| 76.4k| it = copy_it; 3627| 76.4k| rewind_depth(ctx, copy_depth); 3628| 76.4k| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 76.4k| not variant_alternative_exhausted(ctx)) { 3630| 76.4k| ctx.error = error_code::none; 3631| 76.4k| } 3632| 76.4k| } 3633| 76.4k| } 3634| 76.4k| else { 3635| 76.4k| it = copy_it; 3636| 76.4k| rewind_depth(ctx, copy_depth); 3637| 76.4k| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 76.4k| not variant_alternative_exhausted(ctx)) { 3639| 76.4k| ctx.error = error_code::none; 3640| 76.4k| } 3641| 76.4k| } 3642| 76.4k| ++non_const_idx; 3643| 76.4k| } 3644| 76.4k| }); 3645| 76.4k| if (!found_match) { ------------------ | Branch (3645:20): [True: 17.2k, False: 59.2k] ------------------ 3646| 17.2k| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 17.2k| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 76.4k| } 3659| 76.4k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3589| 76.4k| for_each([&]() { 3590| 76.4k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 76.4k] | Branch (3590:38): [True: 0, False: 76.4k] | Branch (3590:51): [True: 0, False: 76.4k] ------------------ 3591| 0| return; 3592| 0| } 3593| 76.4k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 76.4k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3589| 76.4k| for_each([&]() { 3590| 76.4k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 76.4k] | Branch (3590:38): [True: 0, False: 76.4k] | Branch (3590:51): [True: 0, False: 76.4k] ------------------ 3591| 0| return; 3592| 0| } 3593| 76.4k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 76.4k| }); _ZZN3glz28process_variant_alternativesINSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSG_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm2EEEDav: 3589| 76.4k| for_each([&]() { 3590| 76.4k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 76.4k] | Branch (3590:38): [True: 0, False: 76.4k] | Branch (3590:51): [True: 0, False: 76.4k] ------------------ 3591| 0| return; 3592| 0| } 3593| 76.4k| using V = std::variant_alternative_t; 3594| 76.4k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 76.4k| auto copy_it{it}; 3596| 76.4k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 76.4k| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 56.0k, False: 20.4k] ------------------ 3598| 56.0k| value = V{}; 3599| 56.0k| } 3600| 76.4k| parse::op()>(std::get(value), ctx, it, end); 3601| 76.4k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 20.2k, False: 56.2k] | Branch (3601:45): [True: 0, False: 20.2k] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 76.4k| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 56.2k, False: 20.2k] ------------------ 3605| 56.2k| found_match = true; 3606| 56.2k| } 3607| 20.2k| else if constexpr (not Options.null_terminated) { 3608| 20.2k| constexpr bool is_complete_type = 3609| 20.2k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [True: 20.2k, Folded] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [Folded, False: 0] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| 20.2k| if constexpr (is_complete_type) { 3612| 20.2k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3612:32): [True: 2.99k, False: 17.2k] | Branch (3612:72): [True: 2.99k, False: 0] | Branch (3612:88): [True: 2.99k, False: 0] ------------------ 3613| 2.99k| found_match = true; 3614| 2.99k| ctx.error = error_code::none; 3615| 2.99k| } 3616| 17.2k| else { 3617| 17.2k| it = copy_it; 3618| 17.2k| rewind_depth(ctx, copy_depth); 3619| 17.2k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3619:35): [True: 0, False: 17.2k] | Branch (3619:74): [True: 0, False: 0] ------------------ 3620| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3620:35): [True: 0, False: 0] ------------------ 3621| 0| ctx.error = error_code::none; 3622| 0| } 3623| 17.2k| } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 76.4k| ++non_const_idx; 3643| 76.4k| } 3644| 76.4k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERlTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 76.4k| { 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| 76.4k| else { 60| 76.4k| using V = std::remove_cvref_t; 61| 76.4k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 76.4k| end); 63| 76.4k| } 64| 76.4k| } _ZN3glz4fromILj10ElE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRlTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 763| 76.4k| { 764| | if constexpr (check_quoted_num(Opts)) { 765| | if (skip_ws(ctx, it, end)) { 766| | return; 767| | } 768| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 769| | return; 770| | } 771| | } 772| | 773| | if constexpr (!check_ws_handled(Opts)) { 774| | if (skip_ws(ctx, it, end)) { 775| | return; 776| | } 777| | } 778| | 779| 76.4k| using V = std::decay_t; 780| 76.4k| if constexpr (int_t) { 781| 76.4k| static_assert(sizeof(*it) == sizeof(char)); 782| | 783| | if constexpr (Opts.null_terminated) { 784| | if (not glz::atoi(value, it)) [[unlikely]] { 785| | ctx.error = error_code::parse_number_failure; 786| | return; 787| | } 788| | } 789| 76.4k| else { 790| 76.4k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (790:20): [True: 17.2k, False: 59.2k] ------------------ 791| 17.2k| ctx.error = error_code::parse_number_failure; 792| 17.2k| return; 793| 17.2k| } 794| 76.4k| } 795| | } 796| | else { 797| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 798| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 799| | if constexpr (is_float128) { 800| | auto [ptr, ec] = std::from_chars(it, end, value); 801| | if (ec != std::errc()) { 802| | ctx.error = error_code::parse_number_failure; 803| | return; 804| | } 805| | it = ptr; 806| | } 807| | else 808| |#endif 809| | { 810| | if constexpr (std::is_volatile_v>) { 811| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 812| | // place 813| | V temp; 814| | if constexpr (is_size_optimized(Opts)) { 815| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 816| | if (ec != std::errc{}) [[unlikely]] { 817| | ctx.error = error_code::parse_number_failure; 818| | return; 819| | } 820| | it = ptr; 821| | } 822| | else { 823| | auto [ptr, ec] = glz::from_chars(it, end, temp); 824| | if (ec != std::errc()) [[unlikely]] { 825| | ctx.error = error_code::parse_number_failure; 826| | return; 827| | } 828| | it = ptr; 829| | } 830| | value = temp; 831| | } 832| | else { 833| | if constexpr (is_size_optimized(Opts)) { 834| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 835| | if (ec != std::errc{}) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | it = ptr; 840| | } 841| | else { 842| | auto [ptr, ec] = glz::from_chars(it, end, value); 843| | if (ec != std::errc()) [[unlikely]] { 844| | ctx.error = error_code::parse_number_failure; 845| | return; 846| | } 847| | it = ptr; 848| | } 849| | } 850| | } 851| | } 852| | 853| | if constexpr (check_quoted_num(Opts)) { 854| | if constexpr (not Opts.null_terminated) { 855| | if (it == end) [[unlikely]] { 856| | ctx.error = error_code::unexpected_end; 857| | return; 858| | } 859| | } 860| | if (match<'"'>(ctx, it)) { 861| | return; 862| | } 863| | if constexpr (not Opts.null_terminated) { 864| | if (it == end) { 865| | ctx.error = error_code::end_reached; 866| | return; 867| | } 868| | } 869| | } 870| 76.4k| else { 871| 76.4k| if constexpr (not Opts.null_terminated) { 872| 76.4k| if (it == end) { ------------------ | Branch (872:20): [True: 2.99k, False: 73.4k] ------------------ 873| 2.99k| ctx.error = error_code::end_reached; 874| 2.99k| return; 875| 2.99k| } 876| 76.4k| } 877| 76.4k| } 878| 76.4k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERNS_4skipETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 49| 252k| { 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| 252k| else { 60| 252k| using V = std::remove_cvref_t; 61| 252k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 252k| end); 63| 252k| } 64| 252k| } _ZN3glz4fromILj10ENS_4skipEE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEERS1_TkNS_10is_contextERNS_7contextEJRPKcSC_EEEvOT0_OT1_DpOT2_: 570| 252k| { 571| 252k| skip_value::op(ctx, args...); 572| 252k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJDnNS4_17basic_string_viewIcNS4_11char_traitsIcEEEElEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 20.6k| { 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| 20.6k| else { 60| 20.6k| using V = std::remove_cvref_t; 61| 20.6k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 20.6k| end); 63| 20.6k| } 64| 20.6k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 3860| 20.6k| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 20.6k| else { 3865| 20.6k| read_deduced(value, ctx, it, end); 3866| 20.6k| } 3867| 20.6k| } _ZN3glz4fromILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 3871| 20.6k| { 3872| 20.6k| constexpr auto Opts = ws_handled_off(); 3873| 20.6k| if constexpr (variant_is_auto_deducible()) { 3874| 20.6k| if constexpr (not check_ws_handled(Options)) { 3875| 20.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3875:20): [True: 0, False: 20.6k] ------------------ 3876| 0| return; 3877| 0| } 3878| 20.6k| } 3879| | 3880| 20.6k| switch (*it) { 3881| 0| case '\0': ------------------ | Branch (3881:13): [True: 0, False: 20.6k] ------------------ 3882| 0| ctx.error = error_code::unexpected_end; 3883| 0| return; 3884| 3.99k| case '{': { ------------------ | Branch (3884:13): [True: 3.99k, False: 16.6k] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 3.99k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 3.99k] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 3.99k| ++it; 3894| 3.99k| if constexpr (not Opts.null_terminated) { 3895| 3.99k| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 0, False: 3.99k] ------------------ 3896| 0| ctx.error = error_code::unexpected_end; 3897| 0| return; 3898| 0| } 3899| 3.99k| } 3900| 3.99k| using type_counts = variant_type_count; 3901| 3.99k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| 3.99k| if constexpr (n_object_candidates < 1) { 3903| 3.99k| ctx.error = error_code::no_matching_variant_type; 3904| 3.99k| return; 3905| | } 3906| | else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| | constexpr auto first_idx = variant_first_object_candidate_v; 3908| | using V = std::variant_alternative_t; 3909| | if (!std::holds_alternative(value)) value = V{}; 3910| | parse::op()>(std::get(value), ctx, it, end); 3911| | return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 3.99k| } 4596| 2.95k| case '[': ------------------ | Branch (4596:13): [True: 2.95k, False: 17.7k] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 2.95k| process_variant_alternatives::template op(value, ctx, it, end); 4599| 2.95k| break; 4600| 2.92k| case '"': { ------------------ | Branch (4600:13): [True: 2.92k, False: 17.7k] ------------------ 4601| 2.92k| process_variant_alternatives::template op(value, ctx, it, end); 4602| 2.92k| break; 4603| 3.99k| } 4604| 321| case 't': ------------------ | Branch (4604:13): [True: 321, False: 20.3k] ------------------ 4605| 520| case 'f': { ------------------ | Branch (4605:13): [True: 199, False: 20.4k] ------------------ 4606| 520| process_variant_alternatives::template op(value, ctx, it, end); 4607| 520| break; 4608| 321| } 4609| 222| case 'n': ------------------ | Branch (4609:13): [True: 222, False: 20.4k] ------------------ 4610| | if constexpr (variant_count_v == 0) { 4611| | ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| 222| else { 4614| 222| constexpr auto first_idx = variant_first_index_v; 4615| 222| using V = std::variant_alternative_t; 4616| 222| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4616:23): [True: 0, False: 222] ------------------ 4617| 222| match<"null", Opts>(ctx, it, end); 4618| 222| } 4619| 222| break; 4620| 10.0k| default: { ------------------ | Branch (4620:13): [True: 10.0k, False: 10.6k] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 10.0k| process_variant_alternatives::template op(value, ctx, it, end); 4623| 10.0k| } 4624| 20.6k| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 20.6k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 49| 75.5k| { 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| 75.5k| else { 60| 75.5k| using V = std::remove_cvref_t; 61| 75.5k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 75.5k| end); 63| 75.5k| } 64| 75.5k| } _ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 150| 75.5k| { 151| 75.5k| using V = std::decay_t(), meta_wrapper_v))>; 152| 75.5k| from::template op(get_member(std::forward(value), meta_wrapper_v), 153| 75.5k| std::forward(ctx), std::forward(it), end); 154| 75.5k| } _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_: 3860| 75.5k| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 75.5k| else { 3865| 75.5k| read_deduced(value, ctx, it, end); 3866| 75.5k| } 3867| 75.5k| } _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_: 3871| 75.5k| { 3872| 75.5k| constexpr auto Opts = ws_handled_off(); 3873| 75.5k| if constexpr (variant_is_auto_deducible()) { 3874| 75.5k| if constexpr (not check_ws_handled(Options)) { 3875| 75.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3875:20): [True: 0, False: 75.5k] ------------------ 3876| 0| return; 3877| 0| } 3878| 75.5k| } 3879| | 3880| 75.5k| switch (*it) { 3881| 0| case '\0': ------------------ | Branch (3881:13): [True: 0, False: 75.5k] ------------------ 3882| 0| ctx.error = error_code::unexpected_end; 3883| 0| return; 3884| 55.2k| case '{': { ------------------ | Branch (3884:13): [True: 55.2k, False: 20.3k] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 55.2k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 55.2k] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 55.2k| ++it; 3894| 55.2k| if constexpr (not Opts.null_terminated) { 3895| 55.2k| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 0, False: 55.2k] ------------------ 3896| 0| ctx.error = error_code::unexpected_end; 3897| 0| return; 3898| 0| } 3899| 55.2k| } 3900| 55.2k| using type_counts = variant_type_count; 3901| 55.2k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| | if constexpr (n_object_candidates < 1) { 3903| | ctx.error = error_code::no_matching_variant_type; 3904| | return; 3905| | } 3906| 55.2k| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| 55.2k| constexpr auto first_idx = variant_first_object_candidate_v; 3908| 55.2k| using V = std::variant_alternative_t; 3909| 55.2k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (3909:23): [True: 55.2k, False: 0] ------------------ 3910| 55.2k| parse::op()>(std::get(value), ctx, it, end); 3911| 55.2k| return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 55.2k| } 4596| 20.3k| case '[': ------------------ | Branch (4596:13): [True: 20.3k, False: 55.2k] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 20.3k| process_variant_alternatives::template op(value, ctx, it, end); 4599| 20.3k| break; 4600| 0| case '"': { ------------------ | Branch (4600:13): [True: 0, False: 75.5k] ------------------ 4601| 0| process_variant_alternatives::template op(value, ctx, it, end); 4602| 0| break; 4603| 55.2k| } 4604| 0| case 't': ------------------ | Branch (4604:13): [True: 0, False: 75.5k] ------------------ 4605| 0| case 'f': { ------------------ | Branch (4605:13): [True: 0, False: 75.5k] ------------------ 4606| 0| process_variant_alternatives::template op(value, ctx, it, end); 4607| 0| break; 4608| 0| } 4609| 0| case 'n': ------------------ | Branch (4609:13): [True: 0, False: 75.5k] ------------------ 4610| | if constexpr (variant_count_v == 0) { 4611| | ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| 0| else { 4614| 0| constexpr auto first_idx = variant_first_index_v; 4615| 0| using V = std::variant_alternative_t; 4616| 0| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4616:23): [True: 0, False: 0] ------------------ 4617| 0| match<"null", Opts>(ctx, it, end); 4618| 0| } 4619| 0| break; 4620| 0| default: { ------------------ | Branch (4620:13): [True: 0, False: 75.5k] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 0| process_variant_alternatives::template op(value, ctx, it, end); 4623| 0| } 4624| 75.5k| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 75.5k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERNS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES4_EEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 1.10M| { 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.10M| else { 60| 1.10M| using V = std::remove_cvref_t; 61| 1.10M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 1.10M| end); 63| 1.10M| } 64| 1.10M| } _ZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_: 2791| 1.10M| { 2792| 1.10M| static constexpr auto num_members = reflect::size; 2793| | 2794| 1.10M| static constexpr auto Opts = opening_handled_off()>(); 2795| | if constexpr (!check_opening_handled(Options)) { 2796| | if constexpr (!check_ws_handled(Options)) { 2797| | if (skip_ws(ctx, it, end)) { 2798| | return; 2799| | } 2800| | } 2801| | if (match_invalid_end<'{', Opts>(ctx, it, end)) { 2802| | return; 2803| | } 2804| | if constexpr (not Opts.null_terminated) { 2805| | if (it == end) [[unlikely]] { 2806| | ctx.error = error_code::unexpected_end; 2807| | return; 2808| | } 2809| | } 2810| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2811| | // released at each syntactic close below 2812| | if (enter_depth(ctx)) [[unlikely]] { 2813| | return; 2814| | } 2815| | } 2816| 1.10M| const auto ws_start = it; 2817| 1.10M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2817:14): [True: 0, False: 1.10M] ------------------ 2818| 0| return; 2819| 0| } 2820| 1.10M| const size_t ws_size = size_t(it - ws_start); 2821| | 2822| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 2823| | if constexpr (not tag.sv().empty()) { 2824| | if (*it == '"') { 2825| | ++it; 2826| | if constexpr (not Opts.null_terminated) { 2827| | if (it == end) [[unlikely]] { 2828| | ctx.error = error_code::unexpected_end; 2829| | return; 2830| | } 2831| | } 2832| | 2833| | const auto start = it; 2834| | skip_string_view(ctx, it, end); 2835| | if (bool(ctx.error)) [[unlikely]] 2836| | return; 2837| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 2838| | return; 2839| | const sv key{start, size_t(it - start)}; 2840| | ++it; 2841| | if constexpr (not Opts.null_terminated) { 2842| | if (it == end) [[unlikely]] { 2843| | ctx.error = error_code::unexpected_end; 2844| | return; 2845| | } 2846| | } 2847| | 2848| | if (key == tag.sv()) { 2849| | if (parse_ws_colon(ctx, it, end)) { 2850| | return; 2851| | } 2852| | 2853| | parse::handle_unknown(key, value, ctx, it, end); 2854| | if (bool(ctx.error)) [[unlikely]] 2855| | return; 2856| | 2857| | if (skip_ws(ctx, it, end)) { 2858| | return; 2859| | } 2860| | } 2861| | else { 2862| | ctx.error = error_code::unknown_key; 2863| | return; 2864| | } 2865| | } 2866| | } 2867| | 2868| | if (*it == '}') [[likely]] { 2869| | --ctx.depth; 2870| | if constexpr (glaze_object_t || reflectable) { 2871| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 2872| | auto wrapper = self_constraint_v(value); 2873| | from::template op()>(wrapper, ctx, it, end); 2874| | if (bool(ctx.error)) { 2875| | return; 2876| | } 2877| | } 2878| | } 2879| | ++it; 2880| | if constexpr (not Opts.null_terminated) { 2881| | if (it == end) { 2882| | ctx.error = error_code::end_reached; 2883| | return; 2884| | } 2885| | } 2886| | if constexpr (Opts.partial_read) { 2887| | ctx.error = error_code::partial_read_complete; 2888| | } 2889| | return; 2890| | } 2891| | ctx.error = error_code::unknown_key; 2892| | return; 2893| | } 2894| 1.10M| else { 2895| 1.10M| decltype(auto) fields = [&]() -> decltype(auto) { 2896| 1.10M| if constexpr ((glaze_object_t || reflectable) && 2897| 1.10M| (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| 1.10M| return bit_array{}; 2899| 1.10M| } 2900| 1.10M| else { 2901| 1.10M| return nullptr; 2902| 1.10M| } 2903| 1.10M| }(); 2904| | 2905| | // A file include merges an external document into this object, so with 2906| | // error_on_missing_keys the keys have to be counted across both documents (see 2907| | // context::key_bits). While this object parses, its bits are published for its 2908| | // includer members to hand down; and if this parse is itself an included document, 2909| | // it claims the bits of the object that included us and merges into them at the 2910| | // closing brace instead of running a check of its own. 2911| 1.10M| static constexpr bool tracks_include_keys = [] { 2912| | // Nested so that reflecting over the members is only asked for when it can matter 2913| 1.10M| if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2914| 1.10M| return has_includer_member; 2915| 1.10M| } 2916| 1.10M| else { 2917| 1.10M| return false; 2918| 1.10M| } 2919| 1.10M| }(); 2920| 1.10M| [[maybe_unused]] bit_array* include_bits{}; 2921| | if constexpr (tracks_include_keys) { 2922| | if (ctx.include_key_type == &include_key_tag) { 2923| | include_bits = static_cast*>(ctx.include_key_bits); 2924| | ctx.include_key_bits = nullptr; 2925| | ctx.include_key_type = nullptr; 2926| | } 2927| | } 2928| 1.10M| [[maybe_unused]] const std::conditional_t>, 2930| 1.10M| inert_key_bits_scope> published_bits{ 2931| 1.10M| ctx, [&]() -> void* { 2932| 1.10M| if constexpr (tracks_include_keys) { 2933| 1.10M| return &fields; 2934| 1.10M| } 2935| 1.10M| else { 2936| 1.10M| return nullptr; 2937| 1.10M| } 2938| 1.10M| }()}; 2939| | 2940| 1.10M| size_t read_count{}; // for partial_read 2941| | 2942| 1.10M| bool first = true; 2943| 4.39M| while (true) { ------------------ | Branch (2943:20): [True: 4.34M, Folded] ------------------ 2944| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 2945| | static constexpr bit_array all_fields = [] { 2946| | bit_array arr{}; 2947| | for (size_t i = 0; i < num_members; ++i) { 2948| | arr[i] = true; 2949| | } 2950| | return arr; 2951| | }(); 2952| | 2953| | if ((all_fields & fields) == all_fields) { 2954| | ctx.error = error_code::partial_read_complete; 2955| | --ctx.depth; // as above: an early success still closes this level 2956| | return; 2957| | } 2958| | } 2959| | 2960| | // Streaming refill point: at start of each iteration, ensure buffer has data 2961| | if constexpr (has_streaming_state) { 2962| | if (ctx.stream.enabled()) { 2963| | const size_t consumed = static_cast(it - ctx.stream.data()); 2964| | const size_t remaining = ctx.stream.size() - consumed; 2965| | // Refill when less than half of buffer remains to ensure space for next key-value pair 2966| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2967| | const char* new_it; 2968| | const char* new_end; 2969| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2970| | it = new_it; 2971| | end = new_end; 2972| | if (it >= end && ctx.stream.at_eof()) { 2973| | ctx.error = error_code::unexpected_end; 2974| | return; 2975| | } 2976| | } 2977| | } 2978| | } 2979| | 2980| 4.34M| if (*it == '}') { ------------------ | Branch (2980:20): [True: 1.05M, False: 3.29M] ------------------ 2981| 1.05M| --ctx.depth; 2982| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 2983| | const bool defer_to_includer = [&] { 2984| | if constexpr (tracks_include_keys) { 2985| | if (include_bits) { 2986| | // An included document is a fragment: hand the keys it supplied to 2987| | // the object that included it, which checks the union of both. 2988| | *include_bits |= fields; 2989| | return true; 2990| | } 2991| | } 2992| | return false; 2993| | }(); 2994| | constexpr auto req_fields = required_fields(); 2995| | if (not defer_to_includer && (req_fields & fields) != req_fields) { 2996| | for (size_t i = 0; i < num_members; ++i) { 2997| | if (not fields[i] && req_fields[i]) { 2998| | ctx.custom_error_message = reflect::keys[i]; 2999| | // We just return the first missing key in order to avoid heap allocations 3000| | break; 3001| | } 3002| | } 3003| | 3004| | ctx.error = error_code::missing_key; 3005| | return; 3006| | } 3007| | } 3008| | if constexpr (glaze_object_t || reflectable) { 3009| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3010| | auto wrapper = self_constraint_v(value); 3011| | from::template op()>(wrapper, ctx, it, end); 3012| | if (bool(ctx.error)) { 3013| | return; 3014| | } 3015| | } 3016| | } 3017| 1.05M| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3018| 1.05M| if constexpr (not Opts.null_terminated) { 3019| 1.05M| if (it == end) { ------------------ | Branch (3019:26): [True: 35.4k, False: 1.01M] ------------------ 3020| 35.4k| ctx.error = error_code::end_reached; 3021| 35.4k| return; 3022| 35.4k| } 3023| 1.05M| } 3024| 1.01M| return; 3025| 1.05M| } 3026| 3.29M| else if (first) { ------------------ | Branch (3026:25): [True: 1.10M, False: 2.18M] ------------------ 3027| 1.10M| first = false; 3028| 1.10M| } 3029| 2.18M| else { 3030| 2.18M| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3030:23): [True: 0, False: 2.18M] ------------------ 3031| 0| return; 3032| 0| } 3033| 2.18M| if constexpr (not Opts.null_terminated) { 3034| 2.18M| if (it == end) [[unlikely]] { ------------------ | Branch (3034:26): [True: 0, False: 2.18M] ------------------ 3035| 0| ctx.error = error_code::unexpected_end; 3036| 0| return; 3037| 0| } 3038| 2.18M| } 3039| | 3040| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3041| | (!Opts.comments)) { 3042| | if (ws_size && ws_size < size_t(end - it)) { 3043| | skip_matching_ws(ws_start, it, ws_size); 3044| | } 3045| | } 3046| | 3047| 2.18M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3047:23): [True: 0, False: 2.18M] ------------------ 3048| 0| return; 3049| 0| } 3050| 2.18M| } 3051| | 3052| 3.29M| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3052:49): [Folded, False: 0] | Branch (3052:70): [Folded, False: 0] ------------------ 3053| | 3054| | if constexpr (reflection_type && (num_members == 0)) { 3055| | if constexpr (Opts.error_on_unknown_keys) { 3056| | static_assert(false_v, "This should be unreachable"); 3057| | } 3058| | else { 3059| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3060| | return; 3061| | } 3062| | 3063| | // parsing to an empty object, but at this point the JSON presents keys 3064| | 3065| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3066| | // handled by the user. 3067| | 3068| | const auto start = it; 3069| | uint64_t ascii_acc{}; 3070| | skip_string_view(ctx, it, end, ascii_acc); 3071| | if (bool(ctx.error)) [[unlikely]] 3072| | return; 3073| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3074| | return; 3075| | const sv key{start, size_t(it - start)}; 3076| | ++it; 3077| | if constexpr (not Opts.null_terminated) { 3078| | if (it == end) [[unlikely]] { 3079| | ctx.error = error_code::unexpected_end; 3080| | return; 3081| | } 3082| | } 3083| | 3084| | if (parse_ws_colon(ctx, it, end)) { 3085| | return; 3086| | } 3087| | 3088| | // Check if this key is the variant tag that should be skipped 3089| | if constexpr (not tag.sv().empty()) { 3090| | if (key == tag.sv()) { 3091| | // Skip the tag value 3092| | skip_value::op(ctx, it, end); 3093| | if (bool(ctx.error)) [[unlikely]] 3094| | return; 3095| | resync_window_end(ctx, end); // a streaming skip refills 3096| | if (skip_ws(ctx, it, end)) { 3097| | return; 3098| | } 3099| | continue; 3100| | } 3101| | } 3102| | 3103| | parse::handle_unknown(key, value, ctx, it, end); 3104| | if (bool(ctx.error)) [[unlikely]] 3105| | return; 3106| | if constexpr (not Opts.null_terminated) { 3107| | if (it == end) [[unlikely]] { 3108| | ctx.error = error_code::unexpected_end; 3109| | return; 3110| | } 3111| | } 3112| | if (skip_ws(ctx, it, end)) { 3113| | return; 3114| | } 3115| | } 3116| | } 3117| | else if constexpr (reflection_type) { 3118| | static_assert(bool(hash_info.type)); 3119| | 3120| | if (*it != '"') [[unlikely]] { 3121| | ctx.error = error_code::expected_quote; 3122| | return; 3123| | } 3124| | ++it; 3125| | if constexpr (not Opts.null_terminated) { 3126| | if (it == end) [[unlikely]] { 3127| | ctx.error = error_code::unexpected_end; 3128| | return; 3129| | } 3130| | } 3131| | 3132| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3133| | // For tagged variants we first check to see if the key matches the tag 3134| | // We only need to do this if the tag is not part of the keys 3135| | 3136| | const auto start = it; 3137| | uint64_t ascii_acc{}; 3138| | skip_string_view(ctx, it, end, ascii_acc); 3139| | if (bool(ctx.error)) [[unlikely]] 3140| | return; 3141| | if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] 3142| | return; 3143| | const sv key{start, size_t(it - start)}; 3144| | ++it; 3145| | if constexpr (not Opts.null_terminated) { 3146| | if (it == end) [[unlikely]] { 3147| | ctx.error = error_code::unexpected_end; 3148| | return; 3149| | } 3150| | } 3151| | 3152| | if (key == tag.sv()) { 3153| | if (parse_ws_colon(ctx, it, end)) { 3154| | return; 3155| | } 3156| | 3157| | parse::handle_unknown(key, value, ctx, it, end); 3158| | if (bool(ctx.error)) [[unlikely]] 3159| | return; 3160| | 3161| | if (skip_ws(ctx, it, end)) { 3162| | return; 3163| | } 3164| | continue; 3165| | } 3166| | else { 3167| | it = start; // reset the iterator 3168| | } 3169| | } 3170| | 3171| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3172| | size_t index = num_members; 3173| | parse_and_invoke(value, ctx, it, end, index); 3174| | if (bool(ctx.error)) [[unlikely]] 3175| | return; 3176| | if (index < num_members) { 3177| | fields[index] = true; 3178| | } 3179| | } 3180| | else { 3181| | parse_and_invoke(value, ctx, it, end); 3182| | if (bool(ctx.error)) [[unlikely]] 3183| | return; 3184| | } 3185| | } 3186| 3.29M| else { 3187| | // For types like std::map, std::unordered_map 3188| | 3189| 3.29M| auto reading = [&](auto&& key) { 3190| 3.29M| if constexpr (Opts.partial_read) { 3191| 3.29M| if (auto element = value.find(key); element != value.end()) { 3192| 3.29M| ++read_count; 3193| 3.29M| parse::op()>(element->second, ctx, it, end); 3194| 3.29M| } 3195| 3.29M| else { 3196| 3.29M| skip_value::op(ctx, it, end); 3197| 3.29M| } 3198| 3.29M| } 3199| 3.29M| else { 3200| 3.29M| parse::op()>(value[key], ctx, it, end); 3201| 3.29M| } 3202| 3.29M| }; 3203| | 3204| | // using Key = std::conditional_t, sv, typename T::key_type>; 3205| 3.29M| using Key = typename T::key_type; 3206| 3.29M| if constexpr (std::is_same_v) { 3207| 3.29M| ctx.scratch.clear(); 3208| 3.29M| parse::op(ctx.scratch, ctx, it, end); 3209| 3.29M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3209:26): [True: 0, False: 3.29M] ------------------ 3210| 0| return; 3211| | 3212| 3.29M| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3212:26): [True: 0, False: 3.29M] ------------------ 3213| 0| return; 3214| 0| } 3215| | 3216| 3.29M| reading(ctx.scratch); 3217| | if constexpr (Opts.partial_read) { 3218| | if (read_count == value.size()) { 3219| | return; 3220| | } 3221| | } 3222| 3.29M| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3222:26): [True: 51.5k, False: 3.24M] ------------------ 3223| 51.5k| return; 3224| | } 3225| | else if constexpr (str_t) { 3226| | Key key; 3227| | parse::op(key, ctx, it, end); 3228| | if (bool(ctx.error)) [[unlikely]] 3229| | return; 3230| | 3231| | if (parse_ws_colon(ctx, it, end)) { 3232| | return; 3233| | } 3234| | 3235| | reading(key); 3236| | if constexpr (Opts.partial_read) { 3237| | if (read_count == value.size()) { 3238| | return; 3239| | } 3240| | } 3241| | if (bool(ctx.error)) [[unlikely]] 3242| | return; 3243| | } 3244| | else { 3245| | Key key_value{}; 3246| | if constexpr (is_named_enum || mimics_str_t) { 3247| | parse::op(key_value, ctx, it, end); 3248| | } 3249| | else if constexpr (std::is_arithmetic_v) { 3250| | // prefer over quoted_t below to avoid double parsing of quoted_t 3251| | parse::op>(key_value, ctx, it, end); 3252| | } 3253| | else { 3254| | parse::op>(quoted_t{key_value}, ctx, it, end); 3255| | } 3256| | if (bool(ctx.error)) [[unlikely]] 3257| | return; 3258| | 3259| | if (parse_ws_colon(ctx, it, end)) { 3260| | return; 3261| | } 3262| | 3263| | reading(key_value); 3264| | if constexpr (Opts.partial_read) { 3265| | if (read_count == value.size()) { 3266| | return; 3267| | } 3268| | } 3269| | if (bool(ctx.error)) [[unlikely]] 3270| | return; 3271| | } 3272| 3.29M| } 3273| | 3274| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3275| | if constexpr (has_streaming_state) { 3276| | if (ctx.stream.enabled()) { 3277| | const size_t consumed = static_cast(it - ctx.stream.data()); 3278| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3279| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3280| | const char* new_it; 3281| | const char* new_end; 3282| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3283| | it = new_it; 3284| | end = new_end; 3285| | if (it >= end && ctx.stream.at_eof()) { 3286| | ctx.error = error_code::unexpected_end; 3287| | return; 3288| | } 3289| | } 3290| | } 3291| | } 3292| | 3293| 3.29M| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3293:20): [True: 0, False: 3.29M] ------------------ 3294| 0| return; 3295| 0| } 3296| 3.29M| } 3297| 1.10M| } 3298| 1.10M| } _ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 2895| 1.10M| decltype(auto) fields = [&]() -> decltype(auto) { 2896| | if constexpr ((glaze_object_t || reflectable) && 2897| | (Opts.error_on_missing_keys || Opts.partial_read)) { 2898| | return bit_array{}; 2899| | } 2900| 1.10M| else { 2901| 1.10M| return nullptr; 2902| 1.10M| } 2903| 1.10M| }(); _ZZN3glz4fromILj10ENS_17ordered_small_mapINS_12generic_jsonILNS_8num_modeE0ES1_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS9_ILm1EEEEERS5_TkNS_10is_contextERNS_7contextERPKcSF_EEvOT1_OT2_OT3_T4_ENKUlvE1_clEv: 2931| 1.10M| ctx, [&]() -> void* { 2932| | if constexpr (tracks_include_keys) { 2933| | return &fields; 2934| | } 2935| 1.10M| else { 2936| 1.10M| return nullptr; 2937| 1.10M| } 2938| 1.10M| }()}; _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_: 3189| 3.29M| auto reading = [&](auto&& key) { 3190| | if constexpr (Opts.partial_read) { 3191| | if (auto element = value.find(key); element != value.end()) { 3192| | ++read_count; 3193| | parse::op()>(element->second, ctx, it, end); 3194| | } 3195| | else { 3196| | skip_value::op(ctx, it, end); 3197| | } 3198| | } 3199| 3.29M| else { 3200| 3.29M| parse::op()>(value[key], ctx, it, end); 3201| 3.29M| } 3202| 3.29M| }; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEETkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 49| 3.79M| { 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.79M| else { 60| 3.79M| using V = std::remove_cvref_t; 61| 3.79M| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 3.79M| end); 63| 3.79M| } 64| 3.79M| } _ZN3glz4fromILj10ENS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS4_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT0_OT1_OT2_T3_: 150| 3.79M| { 151| 3.79M| using V = std::decay_t(), meta_wrapper_v))>; 152| 3.79M| from::template op(get_member(std::forward(value), meta_wrapper_v), 153| 3.79M| std::forward(ctx), std::forward(it), end); 154| 3.79M| } _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_: 3860| 3.79M| { 3861| | if constexpr (tagging == variant_tagging_kind::adjacent) { 3862| | read_adjacent(value, ctx, it, end); 3863| | } 3864| 3.79M| else { 3865| 3.79M| read_deduced(value, ctx, it, end); 3866| 3.79M| } 3867| 3.79M| } _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_: 3871| 3.79M| { 3872| 3.79M| constexpr auto Opts = ws_handled_off(); 3873| 3.79M| if constexpr (variant_is_auto_deducible()) { 3874| | if constexpr (not check_ws_handled(Options)) { 3875| | if (skip_ws(ctx, it, end)) { 3876| | return; 3877| | } 3878| | } 3879| | 3880| 3.79M| switch (*it) { 3881| 0| case '\0': ------------------ | Branch (3881:13): [True: 0, False: 3.79M] ------------------ 3882| 0| ctx.error = error_code::unexpected_end; 3883| 0| return; 3884| 1.05M| case '{': { ------------------ | Branch (3884:13): [True: 1.05M, False: 2.74M] ------------------ 3885| | // This branch consumes the brace itself and hands the object to a reader with 3886| | // `opening_handled`, which therefore does not count the level -- but does release it at 3887| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 3888| | // the reader below. 3889| 1.05M| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3889:20): [True: 0, False: 1.05M] ------------------ 3890| 0| return; 3891| 0| } 3892| | 3893| 1.05M| ++it; 3894| 1.05M| if constexpr (not Opts.null_terminated) { 3895| 1.05M| if (it == end) [[unlikely]] { ------------------ | Branch (3895:23): [True: 0, False: 1.05M] ------------------ 3896| 0| ctx.error = error_code::unexpected_end; 3897| 0| return; 3898| 0| } 3899| 1.05M| } 3900| 1.05M| using type_counts = variant_type_count; 3901| 1.05M| constexpr auto n_object_candidates = variant_object_candidate_count_v; 3902| | if constexpr (n_object_candidates < 1) { 3903| | ctx.error = error_code::no_matching_variant_type; 3904| | return; 3905| | } 3906| 1.05M| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 3907| 1.05M| constexpr auto first_idx = variant_first_object_candidate_v; 3908| 1.05M| using V = std::variant_alternative_t; 3909| 1.05M| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (3909:23): [True: 1.05M, False: 0] ------------------ 3910| 1.05M| parse::op()>(std::get(value), ctx, it, end); 3911| 1.05M| return; 3912| | } 3913| | else { 3914| | auto possible_types = bit_array>{}.flip(); 3915| | static constexpr auto& deduction_bits = variant_deduction_bits; 3916| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 3917| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 3918| | 3919| | // Track if we've encountered a tag and what value it had 3920| | std::optional tag_specified_index{}; 3921| | 3922| | if (skip_ws(ctx, it, end)) { 3923| | return; 3924| | } 3925| | // Once the reader knows which alternative this object holds it may have to read 3926| | // it again from here. Anchor the position rather than keep the pointer: the scan 3927| | // below skips values, and a streaming skip refills, which moves the window out 3928| | // from under a raw pointer (see rewind_anchor). 3929| | auto start = make_rewind_anchor(ctx, it); 3930| | bool first_key = true; 3931| | // Parse bifurcation for tagged variants: 3932| | // 3933| | // Without this optimization, tagged variant parsing always uses two passes: 3934| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 3935| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 3936| | // 3937| | // When the tag is the first key, the second pass redundantly re-reads every 3938| | // field that follows it. This lambda avoids that: if the tag was the first key, 3939| | // it advances past the trailing comma so the object parser picks up at the 3940| | // second field. If the tag was found later, it falls back to the full re-parse. 3941| | // 3942| | // One exception: if the tag name is also a field on the resolved struct 3943| | // (contains_tag), we must re-parse regardless so the value is stored in 3944| | // the struct field. This override is applied inside each std::visit lambda. 3945| | // 3946| | // Either way the rewind can fail under a streaming read: the window only holds so 3947| | // much, and an object wider than it has no start left to return to. 3948| | auto position_after_tag = [&] { 3949| | if (first_key) { 3950| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 3951| | return true; 3952| | } 3953| | return start.rewind(ctx, it, end); // tag came later, re-parse from the beginning 3954| | }; 3955| | // `first_key` also answers "were we reset to the object start", which is what 3956| | // position_after_tag does for every key but the first. 3957| | for (; *it != '}'; first_key = false) { 3958| | if (!first_key) { 3959| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 3960| | return; 3961| | } 3962| | } 3963| | 3964| | if (skip_ws(ctx, it, end)) { 3965| | return; 3966| | } 3967| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3968| | return; 3969| | } 3970| | 3971| | auto* key_start = it; 3972| | skip_string_view(ctx, it, end); 3973| | if (bool(ctx.error)) [[unlikely]] 3974| | return; 3975| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 3976| | return; 3977| | const sv key = {key_start, size_t(it - key_start)}; 3978| | 3979| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3980| | return; 3981| | } 3982| | 3983| | if constexpr (deduction_key_count > 0) { 3984| | // We first check if a tag is defined and see if the key matches the tag 3985| | if constexpr (not tag_v.empty()) { 3986| | if (key == tag_v) { 3987| | if (parse_ws_colon(ctx, it, end)) { 3988| | return; 3989| | } 3990| | 3991| | using id_type = std::decay_t[0])>; 3992| | 3993| | std::conditional_t, id_type, sv> type_id{}; 3994| | if constexpr (std::integral) { 3995| | from::template op()>(type_id, ctx, it, end); 3996| | } 3997| | else { 3998| | // The id is turned into an index below and never leaves this 3999| | // reader, so the view of the window it borrows cannot outlive it. 4000| | parse_transient_string_view()>(type_id, ctx, it, end); 4001| | } 4002| | if (bool(ctx.error)) [[unlikely]] 4003| | return; 4004| | if (skip_ws(ctx, it, end)) { 4005| | return; 4006| | } 4007| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4008| | ctx.error = error_code::syntax_error; 4009| | return; 4010| | } 4011| | 4012| | size_t type_index; 4013| | if constexpr (std::integral) { 4014| | type_index = variant_id_to_index::op(type_id); 4015| | } 4016| | else { 4017| | type_index = variant_id_to_index::op( 4018| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4019| | } 4020| | if (type_index < ids_v.size()) [[likely]] { 4021| | // Check if the deduced types include the tag-specified type 4022| | // If not, the tag doesn't match the fields 4023| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4024| | // is happening. At this point, possible_types has been narrowed by field deduction. 4025| | // Check if the tag-specified type is still possible 4026| | const bool type_is_possible = possible_types[type_index]; 4027| | if (!type_is_possible) { 4028| | // Tag specifies a type that doesn't match the fields seen so far 4029| | ctx.error = error_code::no_matching_variant_type; 4030| | return; 4031| | } 4032| | 4033| | if (!position_after_tag()) return; 4034| | tag_specified_index = type_index; // Store the tag-specified type 4035| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4036| | std::visit( 4037| | [&](auto&& v) { 4038| | using V = std::decay_t; 4039| | constexpr bool is_object = 4040| | (glaze_object_t || reflectable) && not custom_read; 4041| | if constexpr (variant_unit_alternative) { 4042| | // A unit alternative carries no data; its object holds only the 4043| | // discriminator. Consume that body through an empty reflected object so 4044| | // unknown-key policy and terminator handling match every other alternative. 4045| | detail::variant_unit_body unit_body{}; 4046| | from::template op(), 4047| | tag_literal>(unit_body, 4048| | ctx, it, end); 4049| | } 4050| | else if constexpr (is_object) { 4051| | if constexpr (contains_tag()) { 4052| | // tag is a struct field, must re-parse 4053| | if (!start.rewind(ctx, it, end)) return; 4054| | } 4055| | from::template op(), tag_literal>(v, ctx, it, 4056| | end); 4057| | } 4058| | else if constexpr (is_memory_object) { 4059| | if (!v) { 4060| | if constexpr (is_specialization_v) { 4061| | if constexpr (requires { v.emplace(); }) { 4062| | v.emplace(); 4063| | } 4064| | else { 4065| | v = typename V::value_type{}; 4066| | } 4067| | } 4068| | else if constexpr (is_specialization_v) 4069| | v = std::make_unique(); 4070| | else if constexpr (is_specialization_v) 4071| | v = std::make_shared(); 4072| | else if constexpr (constructible) { 4073| | v = meta_construct_v(); 4074| | } 4075| | else if constexpr (std::is_pointer_v && 4076| | can_allocate_raw_pointer>) { 4078| | if (!try_allocate_raw_pointer(v, ctx)) { 4079| | return; 4080| | } 4081| | } 4082| | else { 4083| | ctx.error = error_code::invalid_nullable_read; 4084| | return; 4085| | // Cannot read into unset nullable that is not std::optional, 4086| | // std::unique_ptr, or std::shared_ptr 4087| | } 4088| | } 4089| | if constexpr (contains_tag, tag_literal>()) { 4090| | // tag is a struct field, must re-parse 4091| | if (!start.rewind(ctx, it, end)) return; 4092| | } 4093| | from>::template op(), tag_literal>( 4094| | *v, ctx, it, end); 4095| | } 4096| | else if constexpr (custom_read) { 4097| | // Custom handlers parse the remaining body themselves and do not 4098| | // accept the tag template parameter; the tag was already consumed. 4099| | // This only works when the tag was the first key. If it came later, 4100| | // we were reset to the object start and the custom handler would 4101| | // absorb the tag, so error rather than corrupt the value. 4102| | if (!first_key) { 4103| | ctx.error = error_code::feature_not_supported; 4104| | ctx.custom_error_message = 4105| | "the tag must be the first key for a custom variant alternative"; 4106| | return; 4107| | } 4108| | from::template op()>(v, ctx, it, end); 4109| | } 4110| | }, 4111| | value); 4112| | 4113| | return; // we've decoded our target type 4114| | } 4115| | else [[unlikely]] { 4116| | // Check if we have a default type (ids array shorter than variant) 4117| | constexpr auto ids_size = ids_v.size(); 4118| | constexpr auto variant_size = std::variant_size_v; 4119| | if constexpr (ids_size < variant_size) { 4120| | // Use the first unlabeled type as the default 4121| | const auto default_type_index = ids_size; 4122| | 4123| | if (!position_after_tag()) return; 4124| | tag_specified_index = default_type_index; // Store the default type index 4125| | if (value.index() != default_type_index) 4126| | emplace_runtime_variant(value, default_type_index); 4127| | std::visit( 4128| | [&](auto&& v) { 4129| | using V = std::decay_t; 4130| | constexpr bool is_object = 4131| | (glaze_object_t || reflectable) && not custom_read; 4132| | if constexpr (variant_unit_alternative) { 4133| | // A unit alternative carries no data; its object holds only the 4134| | // discriminator. Consume that body through an empty reflected object so 4135| | // unknown-key policy and terminator handling match every other 4136| | // alternative. 4137| | detail::variant_unit_body unit_body{}; 4138| | from::template op(), 4139| | tag_literal>( 4140| | unit_body, ctx, it, end); 4141| | } 4142| | else if constexpr (is_object) { 4143| | if constexpr (contains_tag()) { 4144| | // tag is a struct field, must re-parse 4145| | if (!start.rewind(ctx, it, end)) return; 4146| | } 4147| | from::template op()>(v, ctx, it, end); 4148| | } 4149| | else if constexpr (is_memory_object) { 4150| | if (!v) { 4151| | if constexpr (is_specialization_v) { 4152| | if constexpr (requires { v.emplace(); }) { 4153| | v.emplace(); 4154| | } 4155| | else { 4156| | v = typename V::value_type{}; 4157| | } 4158| | } 4159| | else if constexpr (is_specialization_v) 4160| | v = std::make_unique(); 4161| | else if constexpr (is_specialization_v) 4162| | v = std::make_shared(); 4163| | else if constexpr (constructible) { 4164| | v = meta_construct_v(); 4165| | } 4166| | else if constexpr (std::is_pointer_v && 4167| | can_allocate_raw_pointer< 4168| | Opts, std::decay_t>) { 4169| | if (!try_allocate_raw_pointer(v, ctx)) { 4170| | return; 4171| | } 4172| | } 4173| | else { 4174| | ctx.error = error_code::invalid_nullable_read; 4175| | return; 4176| | } 4177| | } 4178| | if constexpr (contains_tag, tag_literal>()) { 4179| | // tag is a struct field, must re-parse 4180| | if (!start.rewind(ctx, it, end)) return; 4181| | } 4182| | from>::template op()>(*v, ctx, 4183| | it, end); 4184| | } 4185| | else if constexpr (custom_read) { 4186| | // Custom handlers parse the remaining body themselves; this only 4187| | // works when the tag was the first key (see above). If it came 4188| | // later we were reset to the object start, so error rather than 4189| | // let the custom handler absorb the tag. 4190| | if (!first_key) { 4191| | ctx.error = error_code::feature_not_supported; 4192| | ctx.custom_error_message = 4193| | "the tag must be the first key for a custom variant alternative"; 4194| | return; 4195| | } 4196| | from::template op()>(v, ctx, it, end); 4197| | } 4198| | }, 4199| | value); 4200| | 4201| | return; 4202| | } 4203| | else { 4204| | ctx.error = error_code::no_matching_variant_type; 4205| | ctx.custom_error_message = variant_ids_string_v; 4206| | return; 4207| | } 4208| | } 4209| | } 4210| | } 4211| | 4212| | // Inline decode_hash lookup for variant deduction 4213| | using deduction_keys_t = keys_wrapper>; 4214| | constexpr auto& DeductionHashInfo = hash_info; 4215| | const auto deduction_index = 4216| | decode_hash_with_size::op( 4217| | key.data(), key.data() + key.size(), key.size()); 4218| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4219| | [[likely]] { 4220| | possible_types &= deduction_bits[deduction_index]; 4221| | } 4222| | else if constexpr (Opts.error_on_unknown_keys) { 4223| | ctx.error = error_code::unknown_key; 4224| | return; 4225| | } 4226| | } 4227| | else if constexpr (not tag_v.empty()) { 4228| | // empty object case for variant, if there are no normal elements 4229| | if (key == tag_v) { 4230| | if (parse_ws_colon(ctx, it, end)) { 4231| | return; 4232| | } 4233| | 4234| | // The id is turned into an index below and never leaves this reader, 4235| | // so the view of the window it borrows cannot outlive that window. 4236| | std::string_view type_id{}; 4237| | parse_transient_string_view()>(type_id, ctx, it, end); 4238| | if (bool(ctx.error)) [[unlikely]] 4239| | return; 4240| | if (skip_ws(ctx, it, end)) { 4241| | return; 4242| | } 4243| | 4244| | const auto type_index = variant_id_to_index::op( 4245| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4246| | if (type_index < ids_v.size()) [[likely]] { 4247| | if (!position_after_tag()) return; 4248| | tag_specified_index = type_index; // Store the tag-specified type 4249| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4250| | } 4251| | else { 4252| | // Check if we have a default type (ids array shorter than variant) 4253| | constexpr auto ids_size = ids_v.size(); 4254| | constexpr auto variant_size = std::variant_size_v; 4255| | if constexpr (ids_size < variant_size) { 4256| | // Use the first unlabeled type as the default 4257| | if (!position_after_tag()) return; 4258| | const auto default_index = ids_size; 4259| | tag_specified_index = default_index; // Store the default type index 4260| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4261| | } 4262| | else { 4263| | ctx.error = error_code::no_matching_variant_type; 4264| | ctx.custom_error_message = variant_ids_string_v; 4265| | return; 4266| | } 4267| | } 4268| | // Parse the type (handles tag skipping and unknown keys) 4269| | std::visit( 4270| | [&](auto&& v) { 4271| | using V = std::decay_t; 4272| | if constexpr (custom_read) { 4273| | // Custom handlers parse the remaining object body themselves and do not 4274| | // accept the tag template parameter that reflected objects use to skip an 4275| | // interior tag key. That only works when the tag is the first key (it was 4276| | // just consumed). If the tag came after other keys, position_after_tag() 4277| | // reset us to the object start and the custom handler would absorb the tag 4278| | // into its value, so error here rather than corrupt the result. 4279| | if (!first_key) { 4280| | ctx.error = error_code::feature_not_supported; 4281| | ctx.custom_error_message = 4282| | "the tag must be the first key for a custom variant alternative"; 4283| | return; 4284| | } 4285| | from::template op()>(v, ctx, it, end); 4286| | } 4287| | else { 4288| | if constexpr (contains_tag()) { 4289| | // tag is a struct field, must re-parse 4290| | if (!start.rewind(ctx, it, end)) return; 4291| | } 4292| | from::template op(), tag_literal>(v, ctx, it, end); 4293| | } 4294| | }, 4295| | value); 4296| | return; 4297| | } 4298| | else if constexpr (Opts.error_on_unknown_keys) { 4299| | ctx.error = error_code::unknown_key; 4300| | return; 4301| | } 4302| | else { 4303| | // Skip unknown key's value (non-tag key in empty variant) 4304| | if (parse_ws_colon(ctx, it, end)) { 4305| | return; 4306| | } 4307| | skip_value::op(ctx, it, end); 4308| | if (bool(ctx.error)) [[unlikely]] 4309| | return; 4310| | resync_window_end(ctx, end); // a streaming skip refills 4311| | if (skip_ws(ctx, it, end)) { 4312| | return; 4313| | } 4314| | continue; // Continue loop to find the tag 4315| | } 4316| | } 4317| | else if constexpr (Opts.error_on_unknown_keys) { 4318| | ctx.error = error_code::unknown_key; 4319| | return; 4320| | } 4321| | 4322| | auto matching_types = possible_types.popcount(); 4323| | if (matching_types == 0) { 4324| | ctx.error = error_code::no_matching_variant_type; 4325| | return; 4326| | } 4327| | // Only short-circuit for variants without tags 4328| | else if constexpr (tag_v.empty()) { 4329| | if (matching_types == 1) { 4330| | if (!start.rewind(ctx, it, end)) return; 4331| | const auto type_index = possible_types.countr_zero(); 4332| | 4333| | if (value.index() != static_cast(type_index)) 4334| | emplace_runtime_variant(value, type_index); 4335| | std::visit( 4336| | [&](auto&& v) { 4337| | using V = std::decay_t; 4338| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4339| | if constexpr (variant_unit_alternative) { 4340| | // A unit alternative carries no data; its object holds only the discriminator. 4341| | // Consume that body through an empty reflected object so unknown-key policy and 4342| | // terminator handling match every other alternative. 4343| | detail::variant_unit_body unit_body{}; 4344| | from::template op(), 4345| | tag_literal>(unit_body, ctx, it, 4346| | end); 4347| | } 4348| | else if constexpr (is_object) { 4349| | from::template op(), tag_literal>(v, ctx, it, end); 4350| | } 4351| | else if constexpr (is_memory_object) { 4352| | if (!v) { 4353| | if constexpr (is_specialization_v) { 4354| | if constexpr (requires { v.emplace(); }) { 4355| | v.emplace(); 4356| | } 4357| | else { 4358| | v = typename V::value_type{}; 4359| | } 4360| | } 4361| | else if constexpr (is_specialization_v) 4362| | v = std::make_unique(); 4363| | else if constexpr (is_specialization_v) 4364| | v = std::make_shared(); 4365| | else if constexpr (constructible) { 4366| | v = meta_construct_v(); 4367| | } 4368| | else if constexpr (std::is_pointer_v && 4369| | can_allocate_raw_pointer>) { 4370| | if (!try_allocate_raw_pointer(v, ctx)) { 4371| | return; 4372| | } 4373| | } 4374| | else { 4375| | ctx.error = error_code::invalid_nullable_read; 4376| | return; 4377| | // Cannot read into unset nullable that is not std::optional, 4378| | // std::unique_ptr, or std::shared_ptr 4379| | } 4380| | } 4381| | from>::template op(), tag_literal>( 4382| | *v, ctx, it, end); 4383| | } 4384| | else if constexpr (custom_read) { 4385| | // Custom handlers parse the remaining body themselves. 4386| | from::template op()>(v, ctx, it, end); 4387| | } 4388| | }, 4389| | value); 4390| | 4391| | return; // we've decoded our target type 4392| | } 4393| | } 4394| | // For tagged variants, continue processing to validate tags 4395| | if (parse_ws_colon(ctx, it, end)) { 4396| | return; 4397| | } 4398| | 4399| | skip_value::op(ctx, it, end); 4400| | if (bool(ctx.error)) [[unlikely]] 4401| | return; 4402| | resync_window_end(ctx, end); // a streaming skip refills 4403| | if (skip_ws(ctx, it, end)) { 4404| | return; 4405| | } 4406| | } 4407| | // Only apply ambiguous variant resolution if we have multiple object types 4408| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4409| | // After parsing all keys, check if we have multiple matching types 4410| | // If so, choose the one with the fewest fields 4411| | auto final_matching = possible_types.popcount(); 4412| | if (final_matching == 0) { 4413| | ctx.error = error_code::no_matching_variant_type; 4414| | } 4415| | else if (final_matching == 1) { 4416| | // Single type remains after field deduction 4417| | const auto type_index = possible_types.countr_zero(); 4418| | 4419| | // Validate against tag if one was specified 4420| | if (tag_specified_index.has_value() && 4421| | tag_specified_index.value() != static_cast(type_index)) { 4422| | ctx.error = error_code::no_matching_variant_type; 4423| | return; 4424| | } 4425| | 4426| | if (!start.rewind(ctx, it, end)) return; 4427| | if (value.index() != static_cast(type_index)) 4428| | emplace_runtime_variant(value, type_index); 4429| | std::visit( 4430| | [&](auto&& v) { 4431| | using V = std::decay_t; 4432| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4433| | if constexpr (variant_unit_alternative) { 4434| | // A unit alternative carries no data; its object holds only the discriminator. 4435| | // Consume that body through an empty reflected object so unknown-key policy and 4436| | // terminator handling match every other alternative. 4437| | detail::variant_unit_body unit_body{}; 4438| | from::template op(), 4439| | tag_literal>(unit_body, ctx, it, 4440| | end); 4441| | } 4442| | else if constexpr (is_object) { 4443| | from::template op(), tag_literal>(v, ctx, it, end); 4444| | } 4445| | else if constexpr (is_memory_object) { 4446| | if (!v) { 4447| | if constexpr (is_specialization_v) { 4448| | if constexpr (requires { v.emplace(); }) { 4449| | v.emplace(); 4450| | } 4451| | else { 4452| | v = typename V::value_type{}; 4453| | } 4454| | } 4455| | else if constexpr (is_specialization_v) 4456| | v = std::make_unique(); 4457| | else if constexpr (is_specialization_v) 4458| | v = std::make_shared(); 4459| | else if constexpr (constructible) { 4460| | v = meta_construct_v(); 4461| | } 4462| | else if constexpr (std::is_pointer_v && 4463| | can_allocate_raw_pointer>) { 4464| | if (!try_allocate_raw_pointer(v, ctx)) { 4465| | return; 4466| | } 4467| | } 4468| | else { 4469| | ctx.error = error_code::invalid_nullable_read; 4470| | return; 4471| | } 4472| | } 4473| | from>::template op(), tag_literal>(*v, ctx, 4474| | it, end); 4475| | } 4476| | else if constexpr (custom_read) { 4477| | // Custom handlers parse the remaining body themselves. 4478| | from::template op()>(v, ctx, it, end); 4479| | } 4480| | }, 4481| | value); 4482| | } 4483| | else if (final_matching > 1) { 4484| | constexpr auto N = std::variant_size_v; 4485| | 4486| | // Compile-time array of field counts for each variant type 4487| | constexpr auto field_counts = [](std::index_sequence) { 4488| | return std::array { 4489| | ([]() -> size_t { 4490| | using V = std::decay_t>; 4491| | if constexpr (glaze_object_t || reflectable) { 4492| | return reflect::size; 4493| | } 4494| | else if constexpr (is_memory_object) { 4495| | using X = memory_type; 4496| | if constexpr (glaze_object_t || reflectable) { 4497| | return reflect::size; 4498| | } 4499| | else { 4500| | return (std::numeric_limits::max)(); 4501| | } 4502| | } 4503| | else { 4504| | return (std::numeric_limits::max)(); 4505| | } 4506| | }.template operator()())... 4507| | }; 4508| | }(std::make_index_sequence{}); 4509| | 4510| | // Find the type with minimum field count among the possible types 4511| | size_t min_fields = (std::numeric_limits::max)(); 4512| | size_t chosen_index = N; // Invalid index initially 4513| | 4514| | for (size_t i = 0; i < N; ++i) { 4515| | if (possible_types[i] && field_counts[i] < min_fields) { 4516| | min_fields = field_counts[i]; 4517| | chosen_index = i; 4518| | } 4519| | } 4520| | 4521| | if (chosen_index < N) { 4522| | // Validate against tag if one was specified 4523| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4524| | ctx.error = error_code::no_matching_variant_type; 4525| | return; 4526| | } 4527| | 4528| | if (!start.rewind(ctx, it, end)) return; 4529| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4530| | std::visit( 4531| | [&](auto&& v) { 4532| | using V = std::decay_t; 4533| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4534| | if constexpr (variant_unit_alternative) { 4535| | // A unit alternative carries no data; its object holds only the discriminator. 4536| | // Consume that body through an empty reflected object so unknown-key policy and 4537| | // terminator handling match every other alternative. 4538| | detail::variant_unit_body unit_body{}; 4539| | from::template op(), 4540| | tag_literal>(unit_body, ctx, it, 4541| | end); 4542| | } 4543| | else if constexpr (is_object) { 4544| | from::template op(), tag_literal>(v, ctx, it, end); 4545| | } 4546| | else if constexpr (is_memory_object) { 4547| | if (!v) { 4548| | if constexpr (is_specialization_v) { 4549| | if constexpr (requires { v.emplace(); }) { 4550| | v.emplace(); 4551| | } 4552| | else { 4553| | v = typename V::value_type{}; 4554| | } 4555| | } 4556| | else if constexpr (is_specialization_v) 4557| | v = std::make_unique(); 4558| | else if constexpr (is_specialization_v) 4559| | v = std::make_shared(); 4560| | else if constexpr (constructible) { 4561| | v = meta_construct_v(); 4562| | } 4563| | else if constexpr (std::is_pointer_v && 4564| | can_allocate_raw_pointer>) { 4565| | if (!try_allocate_raw_pointer(v, ctx)) { 4566| | return; 4567| | } 4568| | } 4569| | else { 4570| | ctx.error = error_code::invalid_nullable_read; 4571| | return; 4572| | } 4573| | } 4574| | from>::template op(), tag_literal>( 4575| | *v, ctx, it, end); 4576| | } 4577| | else if constexpr (custom_read) { 4578| | // Custom handlers parse the remaining body themselves. 4579| | from::template op()>(v, ctx, it, end); 4580| | } 4581| | }, 4582| | value); 4583| | } 4584| | else { 4585| | ctx.error = error_code::no_matching_variant_type; 4586| | } 4587| | } 4588| | } 4589| | else { 4590| | // For variants with 0 or 1 object types, use the original error handling 4591| | ctx.error = error_code::no_matching_variant_type; 4592| | } 4593| | } 4594| 0| break; 4595| 1.05M| } 4596| 146| case '[': ------------------ | Branch (4596:13): [True: 146, False: 3.79M] ------------------ 4597| | // As with '{' above: the array reader each alternative goes through counts the level. 4598| 146| process_variant_alternatives::template op(value, ctx, it, end); 4599| 146| break; 4600| 1.65M| case '"': { ------------------ | Branch (4600:13): [True: 1.65M, False: 2.13M] ------------------ 4601| 1.65M| process_variant_alternatives::template op(value, ctx, it, end); 4602| 1.65M| break; 4603| 1.05M| } 4604| 0| case 't': ------------------ | Branch (4604:13): [True: 0, False: 3.79M] ------------------ 4605| 0| case 'f': { ------------------ | Branch (4605:13): [True: 0, False: 3.79M] ------------------ 4606| 0| process_variant_alternatives::template op(value, ctx, it, end); 4607| 0| break; 4608| 0| } 4609| 514k| case 'n': ------------------ | Branch (4609:13): [True: 514k, False: 3.27M] ------------------ 4610| | if constexpr (variant_count_v == 0) { 4611| | ctx.error = error_code::no_matching_variant_type; 4612| | } 4613| 514k| else { 4614| 514k| constexpr auto first_idx = variant_first_index_v; 4615| 514k| using V = std::variant_alternative_t; 4616| 514k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4616:23): [True: 0, False: 514k] ------------------ 4617| 514k| match<"null", Opts>(ctx, it, end); 4618| 514k| } 4619| 514k| break; 4620| 571k| default: { ------------------ | Branch (4620:13): [True: 571k, False: 3.22M] ------------------ 4621| | // Not bool, string, object, or array so must be number or null 4622| 571k| process_variant_alternatives::template op(value, ctx, it, end); 4623| 571k| } 4624| 3.79M| } 4625| | } 4626| | else { 4627| | // For non-auto-deducible variants, try each type until one succeeds 4628| | constexpr auto N = std::variant_size_v; 4629| | bool parsed = false; 4630| | bool exhausted = false; // speculation budget spent; see charge_speculation 4631| | 4632| | for_each([&]() { 4633| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4634| | 4635| | auto copy_it = it; 4636| | // A rejected alternative may have bailed out inside a container, which leaves its 4637| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4638| | const auto copy_depth = ctx.depth; 4639| | 4640| | // Try parsing as this type 4641| | if (value.index() != I) { 4642| | emplace_runtime_variant(value, I); 4643| | } 4644| | 4645| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4646| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4647| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4648| | } 4649| | 4650| | if (!bool(ctx.error)) { 4651| | parsed = true; 4652| | } 4653| | else if constexpr (not Options.null_terminated) { 4654| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4655| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4656| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4657| | // We advanced the iterator, so we did parse something -- unless what advanced it 4658| | // was an abandoned attempt, which is what a spent speculation budget means. 4659| | parsed = true; 4660| | ctx.error = error_code::none; 4661| | } 4662| | else { 4663| | // Reset for next attempt (unless this is the last type) 4664| | it = copy_it; 4665| | rewind_depth(ctx, copy_depth); 4666| | if constexpr (I + 1 < N) { 4667| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4668| | ctx.error = error_code::none; // Clear error for next attempt 4669| | } 4670| | } 4671| | } 4672| | } 4673| | else { 4674| | // Reset for next attempt (unless this is the last type) 4675| | it = copy_it; 4676| | rewind_depth(ctx, copy_depth); 4677| | if constexpr (I + 1 < N) { 4678| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4679| | ctx.error = error_code::none; // Clear error for next attempt 4680| | } 4681| | } 4682| | } 4683| | }); 4684| | } 4685| 3.79M| } _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_: 3520| 20.5k| { 3521| 20.5k| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 20.5k| else { 3527| 20.5k| constexpr auto N = std::variant_size_v; 3528| 20.5k| constexpr auto const_count = variant_filtered_count_v; 3529| 20.5k| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 20.5k| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 20.5k| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 20.5k| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 20.5k| size_t non_const_idx = 0; 3588| | 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 20.5k| return; 3592| 20.5k| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| 20.5k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 20.5k| auto copy_it{it}; 3596| 20.5k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 20.5k| if (!std::holds_alternative(value)) { 3598| 20.5k| value = V{}; 3599| 20.5k| } 3600| 20.5k| parse::op()>(std::get(value), ctx, it, end); 3601| 20.5k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 20.5k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 20.5k| } 3604| 20.5k| if (!bool(ctx.error)) { 3605| 20.5k| found_match = true; 3606| 20.5k| } 3607| 20.5k| else if constexpr (not Options.null_terminated) { 3608| 20.5k| constexpr bool is_complete_type = 3609| 20.5k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 20.5k| if constexpr (is_complete_type) { 3612| 20.5k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 20.5k| found_match = true; 3614| 20.5k| ctx.error = error_code::none; 3615| 20.5k| } 3616| 20.5k| else { 3617| 20.5k| it = copy_it; 3618| 20.5k| rewind_depth(ctx, copy_depth); 3619| 20.5k| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 20.5k| not variant_alternative_exhausted(ctx)) { 3621| 20.5k| ctx.error = error_code::none; 3622| 20.5k| } 3623| 20.5k| } 3624| 20.5k| } 3625| 20.5k| else { 3626| 20.5k| it = copy_it; 3627| 20.5k| rewind_depth(ctx, copy_depth); 3628| 20.5k| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 20.5k| not variant_alternative_exhausted(ctx)) { 3630| 20.5k| ctx.error = error_code::none; 3631| 20.5k| } 3632| 20.5k| } 3633| 20.5k| } 3634| 20.5k| else { 3635| 20.5k| it = copy_it; 3636| 20.5k| rewind_depth(ctx, copy_depth); 3637| 20.5k| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 20.5k| not variant_alternative_exhausted(ctx)) { 3639| 20.5k| ctx.error = error_code::none; 3640| 20.5k| } 3641| 20.5k| } 3642| 20.5k| ++non_const_idx; 3643| 20.5k| } 3644| 20.5k| }); 3645| 20.5k| if (!found_match) { ------------------ | Branch (3645:20): [True: 6.18k, False: 14.3k] ------------------ 3646| 6.18k| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 6.18k| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 20.5k| } 3659| 20.5k| } _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 20.5k] | Branch (3590:38): [True: 0, False: 20.5k] | Branch (3590:51): [True: 0, False: 20.5k] ------------------ 3591| 0| return; 3592| 0| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 20.5k| }); _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 20.5k] | Branch (3590:38): [True: 0, False: 20.5k] | Branch (3590:51): [True: 0, False: 20.5k] ------------------ 3591| 0| return; 3592| 0| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 20.5k| }); _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 20.5k] | Branch (3590:38): [True: 0, False: 20.5k] | Branch (3590:51): [True: 0, False: 20.5k] ------------------ 3591| 0| return; 3592| 0| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 20.5k| }); _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 20.5k] | Branch (3590:38): [True: 0, False: 20.5k] | Branch (3590:51): [True: 0, False: 20.5k] ------------------ 3591| 0| return; 3592| 0| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 20.5k| }); _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 20.5k] | Branch (3590:38): [True: 0, False: 20.5k] | Branch (3590:51): [True: 0, False: 20.5k] ------------------ 3591| 0| return; 3592| 0| } 3593| 20.5k| using V = std::variant_alternative_t; 3594| 20.5k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 20.5k| auto copy_it{it}; 3596| 20.5k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 20.5k| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 20.5k, False: 0] ------------------ 3598| 20.5k| value = V{}; 3599| 20.5k| } 3600| 20.5k| parse::op()>(std::get(value), ctx, it, end); 3601| 20.5k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 6.18k, False: 14.3k] | Branch (3601:45): [True: 0, False: 6.18k] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 20.5k| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 14.3k, False: 6.18k] ------------------ 3605| 14.3k| found_match = true; 3606| 14.3k| } 3607| 6.18k| else if constexpr (not Options.null_terminated) { 3608| 6.18k| constexpr bool is_complete_type = 3609| 6.18k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [Folded, False: 0] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [Folded, False: 0] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| 6.18k| else { 3626| 6.18k| it = copy_it; 3627| 6.18k| rewind_depth(ctx, copy_depth); 3628| 6.18k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3628:32): [True: 0, False: 6.18k] | Branch (3628:71): [True: 0, False: 0] ------------------ 3629| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3629:32): [True: 0, False: 0] ------------------ 3630| 0| ctx.error = error_code::none; 3631| 0| } 3632| 6.18k| } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 20.5k| ++non_const_idx; 3643| 20.5k| } 3644| 20.5k| }); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS4_9allocatorIS9_EEEETkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_: 49| 20.5k| { 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| 20.5k| else { 60| 20.5k| using V = std::remove_cvref_t; 61| 20.5k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 20.5k| end); 63| 20.5k| } 64| 20.5k| } _ZN3glz4fromILj10ENSt3__16vectorINS_12generic_jsonILNS_8num_modeE0ENS_17ordered_small_mapEEENS1_9allocatorIS6_EEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS9_TkNS_10is_contextERNS_7contextERPKcSH_EEvOT0_OT1_OT2_T3_: 2050| 20.5k| { 2051| 20.5k| constexpr auto Opts = ws_handled_off(); 2052| | if constexpr (!check_ws_handled(Options)) { 2053| | if (skip_ws(ctx, it, end)) { 2054| | return; 2055| | } 2056| | } 2057| | 2058| 20.5k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2058:14): [True: 0, False: 20.5k] ------------------ 2059| 0| return; 2060| 0| } 2061| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2062| | // released at each syntactic close below 2063| 20.5k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2063:14): [True: 0, False: 20.5k] ------------------ 2064| 0| return; 2065| 0| } 2066| | 2067| 20.5k| const auto ws_start = it; 2068| 20.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2068:14): [True: 0, False: 20.5k] ------------------ 2069| 0| return; 2070| 0| } 2071| | 2072| 20.5k| if (*it == ']') { ------------------ | Branch (2072:14): [True: 146, False: 20.3k] ------------------ 2073| 146| --ctx.depth; 2074| 146| ++it; 2075| 146| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2076| 146| value.clear(); 2077| | 2078| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2079| | value.shrink_to_fit(); 2080| | } 2081| 146| } 2082| 146| return; 2083| 146| } 2084| | 2085| 20.3k| const size_t ws_size = size_t(it - ws_start); 2086| | 2087| 20.3k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2087:49): [True: 20.3k, Folded] | Branch (2087:65): [Folded, False: 0] | Branch (2087:90): [Folded, False: 0] ------------------ 2088| 20.3k| if constexpr (not should_append) { 2089| 20.3k| const auto n = value.size(); 2090| | 2091| 20.3k| auto value_it = value.begin(); 2092| | 2093| 20.3k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2093:32): [True: 0, False: 20.3k] ------------------ 2094| 0| parse::op()>(*value_it++, ctx, it, end); 2095| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2095:20): [True: 0, False: 0] ------------------ 2096| 0| return; 2097| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2097:20): [True: 0, False: 0] ------------------ 2098| 0| return; 2099| 0| } 2100| 0| if (*it == ',') { ------------------ | Branch (2100:20): [True: 0, False: 0] ------------------ 2101| 0| ++it; 2102| | 2103| 0| if constexpr (!Opts.minified && !Opts.comments) { 2104| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2104:26): [True: 0, False: 0] | Branch (2104:37): [True: 0, False: 0] ------------------ 2105| 0| skip_matching_ws(ws_start, it, ws_size); 2106| 0| } 2107| 0| } 2108| | 2109| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2109:23): [True: 0, False: 0] ------------------ 2110| 0| return; 2111| 0| } 2112| 0| } 2113| 0| else if (*it == ']') { ------------------ | Branch (2113:25): [True: 0, False: 0] ------------------ 2114| 0| --ctx.depth; 2115| 0| ++it; 2116| 0| if constexpr (erasable) { 2117| 0| value.erase(value_it, 2118| 0| value.end()); // use erase rather than resize for non-default constructible elements 2119| | 2120| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2121| | value.shrink_to_fit(); 2122| | } 2123| 0| } 2124| 0| return; 2125| 0| } 2126| 0| else [[unlikely]] { 2127| 0| ctx.error = error_code::expected_bracket; 2128| 0| return; 2129| 0| } 2130| 0| } 2131| 20.3k| } 2132| | 2133| | if constexpr (Opts.partial_read) { 2134| | // partial_read stops early on a success path, so give the level back like the 2135| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2136| | --ctx.depth; 2137| | return; 2138| | } 2139| 20.3k| else { 2140| | // growing 2141| 20.3k| if constexpr (emplace_backable || has_try_emplace_back) { 2142| 501k| while (it < end) { ------------------ | Branch (2142:23): [True: 501k, False: 0] ------------------ 2143| | // Streaming refill point: at start of each iteration, ensure buffer has data 2144| | if constexpr (has_streaming_state) { 2145| | if (ctx.stream.enabled()) { 2146| | const size_t consumed = static_cast(it - ctx.stream.data()); 2147| | const size_t remaining = ctx.stream.size() - consumed; 2148| | // Refill when less than half of buffer remains to ensure space for next element 2149| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2150| | const char* new_it; 2151| | const char* new_end; 2152| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2153| | it = new_it; 2154| | end = new_end; 2155| | if (it >= end && ctx.stream.at_eof()) { 2156| | break; // No more data, exit loop normally 2157| | } 2158| | } 2159| | } 2160| | } 2161| | 2162| | if constexpr (has_try_emplace_back) { 2163| | if (value.try_emplace_back()) 2164| | parse::op()>(value.back(), ctx, it, end); 2165| | else 2166| | ctx.error = error_code::exceeded_static_array_size; 2167| | } 2168| 501k| else { 2169| 501k| parse::op()>(value.emplace_back(), ctx, it, end); 2170| 501k| } 2171| | 2172| 501k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2172:23): [True: 6.18k, False: 495k] ------------------ 2173| 6.18k| return; 2174| | 2175| | // Streaming refill point: after parsing each element, refill if buffer is low 2176| | if constexpr (has_streaming_state) { 2177| | if (ctx.stream.enabled()) { 2178| | const size_t consumed = static_cast(it - ctx.stream.data()); 2179| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2180| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2181| | const char* new_it; 2182| | const char* new_end; 2183| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2184| | it = new_it; 2185| | end = new_end; 2186| | if (it >= end && ctx.stream.at_eof()) { 2187| | ctx.error = error_code::unexpected_end; 2188| | return; 2189| | } 2190| | } 2191| | } 2192| | } 2193| | 2194| 495k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2194:23): [True: 0, False: 495k] ------------------ 2195| 0| return; 2196| 0| } 2197| 495k| if (*it == ',') [[likely]] { ------------------ | Branch (2197:23): [True: 481k, False: 14.1k] ------------------ 2198| 481k| ++it; 2199| | 2200| 481k| if constexpr (!Opts.minified && !Opts.comments) { 2201| 481k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2201:29): [True: 0, False: 481k] | Branch (2201:40): [True: 0, False: 0] ------------------ 2202| 0| skip_matching_ws(ws_start, it, ws_size); 2203| 0| } 2204| 481k| } 2205| | 2206| 481k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2206:26): [True: 0, False: 481k] ------------------ 2207| 0| return; 2208| 0| } 2209| 481k| } 2210| 14.1k| else if (*it == ']') { ------------------ | Branch (2210:28): [True: 14.1k, False: 0] ------------------ 2211| 14.1k| --ctx.depth; 2212| 14.1k| ++it; 2213| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2214| | value.shrink_to_fit(); 2215| | } 2216| 14.1k| return; 2217| 14.1k| } 2218| 0| else [[unlikely]] { 2219| 0| ctx.error = error_code::expected_bracket; 2220| 0| return; 2221| 0| } 2222| 495k| } 2223| | 2224| | // A valid array always returns from inside the loop upon reaching ']'. 2225| | // For a null-terminated buffer the loop can only exit here by falling 2226| | // through when `it` reaches the terminator without a closing bracket, 2227| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2228| | // Non-null-terminated buffers surface this through skip_ws/depth 2229| | // tracking (or the streaming refill break), so this guard is limited 2230| | // to the null-terminated case. 2231| | if constexpr (Opts.null_terminated) { 2232| | ctx.error = error_code::unexpected_end; 2233| | } 2234| | } 2235| | else { 2236| | ctx.error = error_code::exceeded_static_array_size; 2237| | } 2238| 20.3k| } 2239| 20.3k| } _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: 3589| 20.5k| for_each([&]() { 3590| 20.5k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 14.3k, False: 6.18k] | Branch (3590:38): [True: 0, False: 6.18k] | Branch (3590:51): [True: 0, False: 6.18k] ------------------ 3591| 14.3k| return; 3592| 14.3k| } 3593| 6.18k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 6.18k| }); _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_: 3520| 1.65M| { 3521| 1.65M| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 1.65M| else { 3527| 1.65M| constexpr auto N = std::variant_size_v; 3528| 1.65M| constexpr auto const_count = variant_filtered_count_v; 3529| 1.65M| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 1.65M| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 1.65M| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 1.65M| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 1.65M| size_t non_const_idx = 0; 3588| | 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 1.65M| return; 3592| 1.65M| } 3593| 1.65M| using V = std::variant_alternative_t; 3594| 1.65M| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 1.65M| auto copy_it{it}; 3596| 1.65M| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 1.65M| if (!std::holds_alternative(value)) { 3598| 1.65M| value = V{}; 3599| 1.65M| } 3600| 1.65M| parse::op()>(std::get(value), ctx, it, end); 3601| 1.65M| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 1.65M| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 1.65M| } 3604| 1.65M| if (!bool(ctx.error)) { 3605| 1.65M| found_match = true; 3606| 1.65M| } 3607| 1.65M| else if constexpr (not Options.null_terminated) { 3608| 1.65M| constexpr bool is_complete_type = 3609| 1.65M| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 1.65M| if constexpr (is_complete_type) { 3612| 1.65M| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 1.65M| found_match = true; 3614| 1.65M| ctx.error = error_code::none; 3615| 1.65M| } 3616| 1.65M| else { 3617| 1.65M| it = copy_it; 3618| 1.65M| rewind_depth(ctx, copy_depth); 3619| 1.65M| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 1.65M| not variant_alternative_exhausted(ctx)) { 3621| 1.65M| ctx.error = error_code::none; 3622| 1.65M| } 3623| 1.65M| } 3624| 1.65M| } 3625| 1.65M| else { 3626| 1.65M| it = copy_it; 3627| 1.65M| rewind_depth(ctx, copy_depth); 3628| 1.65M| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 1.65M| not variant_alternative_exhausted(ctx)) { 3630| 1.65M| ctx.error = error_code::none; 3631| 1.65M| } 3632| 1.65M| } 3633| 1.65M| } 3634| 1.65M| else { 3635| 1.65M| it = copy_it; 3636| 1.65M| rewind_depth(ctx, copy_depth); 3637| 1.65M| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 1.65M| not variant_alternative_exhausted(ctx)) { 3639| 1.65M| ctx.error = error_code::none; 3640| 1.65M| } 3641| 1.65M| } 3642| 1.65M| ++non_const_idx; 3643| 1.65M| } 3644| 1.65M| }); 3645| 1.65M| if (!found_match) { ------------------ | Branch (3645:20): [True: 25.9k, False: 1.63M] ------------------ 3646| 25.9k| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 25.9k| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 1.65M| } 3659| 1.65M| } _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 1.65M] | Branch (3590:38): [True: 0, False: 1.65M] | Branch (3590:51): [True: 0, False: 1.65M] ------------------ 3591| 0| return; 3592| 0| } 3593| 1.65M| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 1.65M| }); _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 1.65M] | Branch (3590:38): [True: 0, False: 1.65M] | Branch (3590:51): [True: 0, False: 1.65M] ------------------ 3591| 0| return; 3592| 0| } 3593| 1.65M| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 1.65M| }); _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 1.65M] | Branch (3590:38): [True: 0, False: 1.65M] | Branch (3590:51): [True: 0, False: 1.65M] ------------------ 3591| 0| return; 3592| 0| } 3593| 1.65M| using V = std::variant_alternative_t; 3594| 1.65M| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 1.65M| auto copy_it{it}; 3596| 1.65M| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 1.65M| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 1.65M, False: 0] ------------------ 3598| 1.65M| value = V{}; 3599| 1.65M| } 3600| 1.65M| parse::op()>(std::get(value), ctx, it, end); 3601| 1.65M| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 25.9k, False: 1.63M] | Branch (3601:45): [True: 0, False: 25.9k] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 1.65M| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 1.63M, False: 25.9k] ------------------ 3605| 1.63M| found_match = true; 3606| 1.63M| } 3607| 25.9k| else if constexpr (not Options.null_terminated) { 3608| 25.9k| constexpr bool is_complete_type = 3609| 25.9k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [Folded, False: 0] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [True: 0, Folded] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| 25.9k| if constexpr (is_complete_type) { 3612| 25.9k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3612:32): [True: 0, False: 25.9k] | Branch (3612:72): [True: 0, False: 0] | Branch (3612:88): [True: 0, False: 0] ------------------ 3613| 0| found_match = true; 3614| 0| ctx.error = error_code::none; 3615| 0| } 3616| 25.9k| else { 3617| 25.9k| it = copy_it; 3618| 25.9k| rewind_depth(ctx, copy_depth); 3619| 25.9k| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3619:35): [True: 0, False: 25.9k] | Branch (3619:74): [True: 0, False: 0] ------------------ 3620| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3620:35): [True: 0, False: 0] ------------------ 3621| 0| ctx.error = error_code::none; 3622| 0| } 3623| 25.9k| } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 1.65M| ++non_const_idx; 3643| 1.65M| } 3644| 1.65M| }); _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 1.63M, False: 25.9k] | Branch (3590:38): [True: 0, False: 25.9k] | Branch (3590:51): [True: 0, False: 25.9k] ------------------ 3591| 1.63M| return; 3592| 1.63M| } 3593| 25.9k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 25.9k| }); _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 1.63M, False: 25.9k] | Branch (3590:38): [True: 0, False: 25.9k] | Branch (3590:51): [True: 0, False: 25.9k] ------------------ 3591| 1.63M| return; 3592| 1.63M| } 3593| 25.9k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 25.9k| }); _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: 3589| 1.65M| for_each([&]() { 3590| 1.65M| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 1.63M, False: 25.9k] | Branch (3590:38): [True: 0, False: 25.9k] | Branch (3590:51): [True: 0, False: 25.9k] ------------------ 3591| 1.63M| return; 3592| 1.63M| } 3593| 25.9k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 25.9k| }); _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_: 3520| 571k| { 3521| 571k| constexpr auto category_count = variant_count_v; 3522| | 3523| | if constexpr (category_count == 0) { 3524| | ctx.error = error_code::no_matching_variant_type; 3525| | } 3526| 571k| else { 3527| 571k| constexpr auto N = std::variant_size_v; 3528| 571k| constexpr auto const_count = variant_filtered_count_v; 3529| 571k| constexpr auto non_const_count = variant_filtered_count_v; 3530| | 3531| 571k| bool found_match{}; 3532| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3533| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3534| | // so the budget stops it and the failure already in hand is reported. 3535| 571k| bool exhausted{}; 3536| | 3537| | // First pass: const glaze types in this category 3538| | if constexpr (const_count > 0) { 3539| | for_each([&]() { 3540| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3541| | return; 3542| | } 3543| | using V = std::variant_alternative_t; 3544| | if constexpr (Trait::value && glaze_const_value_t) { 3545| | // run time substitute to compare to const value 3546| | std::remove_const_t>>> substitute{}; 3547| | auto copy_it{it}; 3548| | // A rejected alternative may have bailed out inside a container, which leaves its 3549| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3550| | // trying N alternatives cannot spend N levels of the recursion budget. 3551| | const auto copy_depth{ctx.depth}; 3552| | parse::op()>(substitute, ctx, it, end); 3553| | static constexpr auto const_value{*meta_wrapper_v}; 3554| | if (substitute == const_value) { 3555| | found_match = true; 3556| | if (!std::holds_alternative(value)) { 3557| | value = V{}; 3558| | } 3559| | } 3560| | else { 3561| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3562| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3563| | exhausted = true; 3564| | } 3565| | if constexpr (not Options.null_terminated) { 3566| | if (ctx.error == error_code::end_reached && not exhausted) { 3567| | ctx.error = error_code::none; 3568| | } 3569| | } 3570| | it = copy_it; 3571| | rewind_depth(ctx, copy_depth); 3572| | } 3573| | } 3574| | }); 3575| | if (found_match) { 3576| | return; 3577| | } 3578| | } 3579| | 3580| | // Second pass: non-const types in this category 3581| 571k| if constexpr (non_const_count > 0) { 3582| | // Track position within matching types for "is last" check. 3583| | // We iterate over all variant indices but only process matching types, 3584| | // so we need runtime tracking (vs the old tuple-based approach where 3585| | // the loop index directly corresponded to position in filtered set). 3586| | // This has negligible cost: one increment per matching type. 3587| 571k| size_t non_const_idx = 0; 3588| | 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3591| 571k| return; 3592| 571k| } 3593| 571k| using V = std::variant_alternative_t; 3594| 571k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 571k| auto copy_it{it}; 3596| 571k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 571k| if (!std::holds_alternative(value)) { 3598| 571k| value = V{}; 3599| 571k| } 3600| 571k| parse::op()>(std::get(value), ctx, it, end); 3601| 571k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| 571k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 571k| } 3604| 571k| if (!bool(ctx.error)) { 3605| 571k| found_match = true; 3606| 571k| } 3607| 571k| else if constexpr (not Options.null_terminated) { 3608| 571k| constexpr bool is_complete_type = 3609| 571k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| 571k| if constexpr (is_complete_type) { 3612| 571k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| 571k| found_match = true; 3614| 571k| ctx.error = error_code::none; 3615| 571k| } 3616| 571k| else { 3617| 571k| it = copy_it; 3618| 571k| rewind_depth(ctx, copy_depth); 3619| 571k| if (non_const_idx + 1 < non_const_count && not exhausted && 3620| 571k| not variant_alternative_exhausted(ctx)) { 3621| 571k| ctx.error = error_code::none; 3622| 571k| } 3623| 571k| } 3624| 571k| } 3625| 571k| else { 3626| 571k| it = copy_it; 3627| 571k| rewind_depth(ctx, copy_depth); 3628| 571k| if (non_const_idx + 1 < non_const_count && not exhausted && 3629| 571k| not variant_alternative_exhausted(ctx)) { 3630| 571k| ctx.error = error_code::none; 3631| 571k| } 3632| 571k| } 3633| 571k| } 3634| 571k| else { 3635| 571k| it = copy_it; 3636| 571k| rewind_depth(ctx, copy_depth); 3637| 571k| if (non_const_idx + 1 < non_const_count && not exhausted && 3638| 571k| not variant_alternative_exhausted(ctx)) { 3639| 571k| ctx.error = error_code::none; 3640| 571k| } 3641| 571k| } 3642| 571k| ++non_const_idx; 3643| 571k| } 3644| 571k| }); 3645| 571k| if (!found_match) { ------------------ | Branch (3645:20): [True: 0, False: 571k] ------------------ 3646| 0| if constexpr (non_const_count == 1) { 3647| | // Keep the specific error from the single type we tried 3648| | } 3649| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3650| | // Over-nested input is not a failure of the alternative set; keep saying so. 3651| | ctx.error = error_code::no_matching_variant_type; 3652| | } 3653| 0| } 3654| | } 3655| | else { 3656| | ctx.error = error_code::no_matching_variant_type; 3657| | } 3658| 571k| } 3659| 571k| } _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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 571k] | Branch (3590:38): [True: 0, False: 571k] | Branch (3590:51): [True: 0, False: 571k] ------------------ 3591| 0| return; 3592| 0| } 3593| 571k| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 571k| }); _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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 0, False: 571k] | Branch (3590:38): [True: 0, False: 571k] | Branch (3590:51): [True: 0, False: 571k] ------------------ 3591| 0| return; 3592| 0| } 3593| 571k| using V = std::variant_alternative_t; 3594| 571k| if constexpr (Trait::value && !glaze_const_value_t) { 3595| 571k| auto copy_it{it}; 3596| 571k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| 571k| if (!std::holds_alternative(value)) { ------------------ | Branch (3597:26): [True: 571k, False: 0] ------------------ 3598| 571k| value = V{}; 3599| 571k| } 3600| 571k| parse::op()>(std::get(value), ctx, it, end); 3601| 571k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3601:26): [True: 0, False: 571k] | Branch (3601:45): [True: 0, False: 0] ------------------ 3602| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| 0| } 3604| 571k| if (!bool(ctx.error)) { ------------------ | Branch (3604:26): [True: 571k, False: 0] ------------------ 3605| 571k| found_match = true; 3606| 571k| } 3607| 0| else if constexpr (not Options.null_terminated) { 3608| 0| constexpr bool is_complete_type = 3609| 0| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3609:28): [True: 0, Folded] | Branch (3609:40): [Folded, False: 0] | Branch (3609:53): [Folded, False: 0] | Branch (3609:68): [Folded, False: 0] | Branch (3609:89): [Folded, False: 0] | Branch (3609:103): [Folded, False: 0] ------------------ 3610| | 3611| 0| if constexpr (is_complete_type) { 3612| 0| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3612:32): [True: 0, False: 0] | Branch (3612:72): [True: 0, False: 0] | Branch (3612:88): [True: 0, False: 0] ------------------ 3613| 0| found_match = true; 3614| 0| ctx.error = error_code::none; 3615| 0| } 3616| 0| else { 3617| 0| it = copy_it; 3618| 0| rewind_depth(ctx, copy_depth); 3619| 0| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3619:35): [True: 0, False: 0] | Branch (3619:74): [True: 0, False: 0] ------------------ 3620| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3620:35): [True: 0, False: 0] ------------------ 3621| 0| ctx.error = error_code::none; 3622| 0| } 3623| 0| } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| 571k| ++non_const_idx; 3643| 571k| } 3644| 571k| }); _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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 571k, False: 0] | Branch (3590:38): [True: 0, False: 0] | Branch (3590:51): [True: 0, False: 0] ------------------ 3591| 571k| return; 3592| 571k| } 3593| 0| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 571k, False: 0] | Branch (3590:38): [True: 0, False: 0] | Branch (3590:51): [True: 0, False: 0] ------------------ 3591| 571k| return; 3592| 571k| } 3593| 0| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 571k, False: 0] | Branch (3590:38): [True: 0, False: 0] | Branch (3590:51): [True: 0, False: 0] ------------------ 3591| 571k| return; 3592| 571k| } 3593| 0| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 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: 3589| 571k| for_each([&]() { 3590| 571k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3590:23): [True: 571k, False: 0] | Branch (3590:38): [True: 0, False: 0] | Branch (3590:51): [True: 0, False: 0] ------------------ 3591| 571k| return; 3592| 571k| } 3593| 0| using V = std::variant_alternative_t; 3594| | if constexpr (Trait::value && !glaze_const_value_t) { 3595| | auto copy_it{it}; 3596| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3597| | if (!std::holds_alternative(value)) { 3598| | value = V{}; 3599| | } 3600| | parse::op()>(std::get(value), ctx, it, end); 3601| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3602| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3603| | } 3604| | if (!bool(ctx.error)) { 3605| | found_match = true; 3606| | } 3607| | else if constexpr (not Options.null_terminated) { 3608| | constexpr bool is_complete_type = 3609| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3610| | 3611| | if constexpr (is_complete_type) { 3612| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3613| | found_match = true; 3614| | ctx.error = error_code::none; 3615| | } 3616| | else { 3617| | it = copy_it; 3618| | rewind_depth(ctx, copy_depth); 3619| | if (non_const_idx + 1 < non_const_count && not exhausted && 3620| | not variant_alternative_exhausted(ctx)) { 3621| | ctx.error = error_code::none; 3622| | } 3623| | } 3624| | } 3625| | else { 3626| | it = copy_it; 3627| | rewind_depth(ctx, copy_depth); 3628| | if (non_const_idx + 1 < non_const_count && not exhausted && 3629| | not variant_alternative_exhausted(ctx)) { 3630| | ctx.error = error_code::none; 3631| | } 3632| | } 3633| | } 3634| | else { 3635| | it = copy_it; 3636| | rewind_depth(ctx, copy_depth); 3637| | if (non_const_idx + 1 < non_const_count && not exhausted && 3638| | not variant_alternative_exhausted(ctx)) { 3639| | ctx.error = error_code::none; 3640| | } 3641| | } 3642| | ++non_const_idx; 3643| | } 3644| 0| }); _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_: 325| 32.2k| { 326| 32.2k| using namespace glz::detail; 327| | 328| | // Validating skips (parse_value/JSON pointer) require the full value in a 329| | // contiguous buffer, so streaming refill is not applied there. 330| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 331| | if (ctx.stream.enabled()) { 332| | skip_value_streaming(ctx, it, end); 333| | return; 334| | } 335| | } 336| | 337| 32.2k| if constexpr (not check_validate_skipped(Opts)) { 338| 32.2k| if constexpr (not check_ws_handled(Opts)) { 339| 32.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (339:17): [True: 0, False: 32.2k] ------------------ 340| 0| return; 341| 0| } 342| 32.2k| } 343| 94.6k| while (true) { ------------------ | Branch (343:17): [True: 94.6k, Folded] ------------------ 344| 94.6k| switch (*it) { 345| 4.42k| case '{': ------------------ | Branch (345:13): [True: 4.42k, False: 90.1k] ------------------ 346| 4.42k| ++it; 347| 4.42k| if constexpr (not Opts.null_terminated) { 348| 4.42k| if (it == end) [[unlikely]] { ------------------ | Branch (348:23): [True: 0, False: 4.42k] ------------------ 349| 0| ctx.error = error_code::unexpected_end; 350| 0| return; 351| 0| } 352| 4.42k| } 353| 4.42k| skip_until_closed(ctx, it, end); 354| 4.42k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (354:20): [True: 0, False: 4.42k] ------------------ 355| 0| return; 356| 4.42k| break; 357| 10.4k| case '[': ------------------ | Branch (357:13): [True: 10.4k, False: 84.1k] ------------------ 358| 10.4k| ++it; 359| 10.4k| if constexpr (not Opts.null_terminated) { 360| 10.4k| if (it == end) [[unlikely]] { ------------------ | Branch (360:23): [True: 0, False: 10.4k] ------------------ 361| 0| ctx.error = error_code::unexpected_end; 362| 0| return; 363| 0| } 364| 10.4k| } 365| 10.4k| skip_until_closed(ctx, it, end); 366| 10.4k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (366:20): [True: 0, False: 10.4k] ------------------ 367| 0| return; 368| 10.4k| break; 369| 10.4k| case '"': ------------------ | Branch (369:13): [True: 9.36k, False: 85.2k] ------------------ 370| 9.36k| skip_string(ctx, it, end); 371| 9.36k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (371:20): [True: 0, False: 9.36k] ------------------ 372| 0| return; 373| 9.36k| break; 374| 9.36k| case ',': ------------------ | Branch (374:13): [True: 7.10k, False: 87.5k] ------------------ 375| 8.02k| case '}': ------------------ | Branch (375:13): [True: 923, False: 93.6k] ------------------ 376| 8.02k| case ']': ------------------ | Branch (376:13): [True: 0, False: 94.6k] ------------------ 377| 8.02k| break; 378| 0| case '\0': ------------------ | Branch (378:13): [True: 0, False: 94.6k] ------------------ 379| 0| ctx.error = error_code::unexpected_end; 380| 0| return; 381| 62.3k| default: { ------------------ | Branch (381:13): [True: 62.3k, False: 32.2k] ------------------ 382| 62.3k| ++it; 383| 62.3k| if constexpr (not Opts.null_terminated) { 384| 62.3k| if (it == end) [[unlikely]] { ------------------ | Branch (384:23): [True: 0, False: 62.3k] ------------------ 385| 0| ctx.error = error_code::unexpected_end; 386| 0| return; 387| 0| } 388| 62.3k| } 389| 62.3k| continue; 390| 8.02k| } 391| 94.6k| } 392| | 393| 32.2k| break; 394| 94.6k| } 395| | } 396| | else { 397| | if constexpr (not check_ws_handled(Opts)) { 398| | if (skip_ws(ctx, it, end)) { 399| | return; 400| | } 401| | } 402| | switch (*it) { 403| | case '{': { 404| | skip_object(ctx, it, end); 405| | break; 406| | } 407| | case '[': { 408| | skip_array(ctx, it, end); 409| | break; 410| | } 411| | case '"': { 412| | skip_string(ctx, it, end); 413| | break; 414| | } 415| | case 'n': { 416| | ++it; 417| | match<"ull", Opts>(ctx, it, end); 418| | break; 419| | } 420| | case 'f': { 421| | ++it; 422| | match<"alse", Opts>(ctx, it, end); 423| | break; 424| | } 425| | case 't': { 426| | ++it; 427| | match<"rue", Opts>(ctx, it, end); 428| | break; 429| | } 430| | case '\0': { 431| | ctx.error = error_code::unexpected_end; 432| | break; 433| | } 434| | default: { 435| | skip_number(ctx, it, end); 436| | } 437| | } 438| | } 439| 32.2k| } _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS7_QntdtT_8commentsEEvOT0_OT1_T2_: 325| 4.87M| { 326| 4.87M| using namespace glz::detail; 327| | 328| | // Validating skips (parse_value/JSON pointer) require the full value in a 329| | // contiguous buffer, so streaming refill is not applied there. 330| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 331| | if (ctx.stream.enabled()) { 332| | skip_value_streaming(ctx, it, end); 333| | return; 334| | } 335| | } 336| | 337| 4.87M| if constexpr (not check_validate_skipped(Opts)) { 338| | if constexpr (not check_ws_handled(Opts)) { 339| | if (skip_ws(ctx, it, end)) { 340| | return; 341| | } 342| | } 343| 20.8M| while (true) { ------------------ | Branch (343:17): [True: 20.8M, Folded] ------------------ 344| 20.8M| switch (*it) { 345| 158k| case '{': ------------------ | Branch (345:13): [True: 158k, False: 20.6M] ------------------ 346| 158k| ++it; 347| 158k| if constexpr (not Opts.null_terminated) { 348| 158k| if (it == end) [[unlikely]] { ------------------ | Branch (348:23): [True: 8, False: 158k] ------------------ 349| 8| ctx.error = error_code::unexpected_end; 350| 8| return; 351| 8| } 352| 158k| } 353| 158k| skip_until_closed(ctx, it, end); 354| 158k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (354:20): [True: 4.13k, False: 154k] ------------------ 355| 4.13k| return; 356| 154k| break; 357| 154k| case '[': ------------------ | Branch (357:13): [True: 16.6k, False: 20.8M] ------------------ 358| 16.6k| ++it; 359| 16.6k| if constexpr (not Opts.null_terminated) { 360| 16.6k| if (it == end) [[unlikely]] { ------------------ | Branch (360:23): [True: 3, False: 16.6k] ------------------ 361| 3| ctx.error = error_code::unexpected_end; 362| 3| return; 363| 3| } 364| 16.6k| } 365| 16.6k| skip_until_closed(ctx, it, end); 366| 16.6k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (366:20): [True: 3.81k, False: 12.8k] ------------------ 367| 3.81k| return; 368| 12.8k| break; 369| 21.2k| case '"': ------------------ | Branch (369:13): [True: 21.2k, False: 20.8M] ------------------ 370| 21.2k| skip_string(ctx, it, end); 371| 21.2k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (371:20): [True: 467, False: 20.7k] ------------------ 372| 467| return; 373| 20.7k| break; 374| 4.67M| case ',': ------------------ | Branch (374:13): [True: 4.67M, False: 16.1M] ------------------ 375| 4.68M| case '}': ------------------ | Branch (375:13): [True: 2.69k, False: 20.8M] ------------------ 376| 4.68M| case ']': ------------------ | Branch (376:13): [True: 821, False: 20.8M] ------------------ 377| 4.68M| break; 378| 686| case '\0': ------------------ | Branch (378:13): [True: 686, False: 20.8M] ------------------ 379| 686| ctx.error = error_code::unexpected_end; 380| 686| return; 381| 15.9M| default: { ------------------ | Branch (381:13): [True: 15.9M, False: 4.87M] ------------------ 382| 15.9M| ++it; 383| 15.9M| if constexpr (not Opts.null_terminated) { 384| 15.9M| if (it == end) [[unlikely]] { ------------------ | Branch (384:23): [True: 124, False: 15.9M] ------------------ 385| 124| ctx.error = error_code::unexpected_end; 386| 124| return; 387| 124| } 388| 15.9M| } 389| 15.9M| continue; 390| 4.68M| } 391| 20.8M| } 392| | 393| 4.86M| break; 394| 20.8M| } 395| | } 396| | else { 397| | if constexpr (not check_ws_handled(Opts)) { 398| | if (skip_ws(ctx, it, end)) { 399| | return; 400| | } 401| | } 402| | switch (*it) { 403| | case '{': { 404| | skip_object(ctx, it, end); 405| | break; 406| | } 407| | case '[': { 408| | skip_array(ctx, it, end); 409| | break; 410| | } 411| | case '"': { 412| | skip_string(ctx, it, end); 413| | break; 414| | } 415| | case 'n': { 416| | ++it; 417| | match<"ull", Opts>(ctx, it, end); 418| | break; 419| | } 420| | case 'f': { 421| | ++it; 422| | match<"alse", Opts>(ctx, it, end); 423| | break; 424| | } 425| | case 't': { 426| | ++it; 427| | match<"rue", Opts>(ctx, it, end); 428| | break; 429| | } 430| | case '\0': { 431| | ctx.error = error_code::unexpected_end; 432| | break; 433| | } 434| | default: { 435| | skip_number(ctx, it, end); 436| | } 437| | } 438| | } 439| 4.87M| } _ZN3glz10skip_valueILj10EE2opITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS4_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_QntdtT_8commentsEEvOT0_OT1_T2_: 325| 943k| { 326| 943k| using namespace glz::detail; 327| | 328| | // Validating skips (parse_value/JSON pointer) require the full value in a 329| | // contiguous buffer, so streaming refill is not applied there. 330| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 331| | if (ctx.stream.enabled()) { 332| | skip_value_streaming(ctx, it, end); 333| | return; 334| | } 335| | } 336| | 337| | if constexpr (not check_validate_skipped(Opts)) { 338| | if constexpr (not check_ws_handled(Opts)) { 339| | if (skip_ws(ctx, it, end)) { 340| | return; 341| | } 342| | } 343| | while (true) { 344| | switch (*it) { 345| | case '{': 346| | ++it; 347| | if constexpr (not Opts.null_terminated) { 348| | if (it == end) [[unlikely]] { 349| | ctx.error = error_code::unexpected_end; 350| | return; 351| | } 352| | } 353| | skip_until_closed(ctx, it, end); 354| | if (bool(ctx.error)) [[unlikely]] 355| | return; 356| | break; 357| | case '[': 358| | ++it; 359| | if constexpr (not Opts.null_terminated) { 360| | if (it == end) [[unlikely]] { 361| | ctx.error = error_code::unexpected_end; 362| | return; 363| | } 364| | } 365| | skip_until_closed(ctx, it, end); 366| | if (bool(ctx.error)) [[unlikely]] 367| | return; 368| | break; 369| | case '"': 370| | skip_string(ctx, it, end); 371| | if (bool(ctx.error)) [[unlikely]] 372| | return; 373| | break; 374| | case ',': 375| | case '}': 376| | case ']': 377| | break; 378| | case '\0': 379| | ctx.error = error_code::unexpected_end; 380| | return; 381| | default: { 382| | ++it; 383| | if constexpr (not Opts.null_terminated) { 384| | if (it == end) [[unlikely]] { 385| | ctx.error = error_code::unexpected_end; 386| | return; 387| | } 388| | } 389| | continue; 390| | } 391| | } 392| | 393| | break; 394| | } 395| | } 396| 943k| else { 397| 943k| if constexpr (not check_ws_handled(Opts)) { 398| 943k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (398:17): [True: 14, False: 943k] ------------------ 399| 14| return; 400| 14| } 401| 943k| } 402| 943k| switch (*it) { 403| 108k| case '{': { ------------------ | Branch (403:10): [True: 108k, False: 834k] ------------------ 404| 108k| skip_object(ctx, it, end); 405| 108k| break; 406| 0| } 407| 205k| case '[': { ------------------ | Branch (407:10): [True: 205k, False: 737k] ------------------ 408| 205k| skip_array(ctx, it, end); 409| 205k| break; 410| 0| } 411| 83.5k| case '"': { ------------------ | Branch (411:10): [True: 83.5k, False: 859k] ------------------ 412| 83.5k| skip_string(ctx, it, end); 413| 83.5k| break; 414| 0| } 415| 4.44k| case 'n': { ------------------ | Branch (415:10): [True: 4.44k, False: 938k] ------------------ 416| 4.44k| ++it; 417| 4.44k| match<"ull", Opts>(ctx, it, end); 418| 4.44k| break; 419| 0| } 420| 9.08k| case 'f': { ------------------ | Branch (420:10): [True: 9.08k, False: 934k] ------------------ 421| 9.08k| ++it; 422| 9.08k| match<"alse", Opts>(ctx, it, end); 423| 9.08k| break; 424| 0| } 425| 3.17k| case 't': { ------------------ | Branch (425:10): [True: 3.17k, False: 939k] ------------------ 426| 3.17k| ++it; 427| 3.17k| match<"rue", Opts>(ctx, it, end); 428| 3.17k| break; 429| 0| } 430| 1.56k| case '\0': { ------------------ | Branch (430:10): [True: 1.56k, False: 941k] ------------------ 431| 1.56k| ctx.error = error_code::unexpected_end; 432| 1.56k| break; 433| 0| } 434| 527k| default: { ------------------ | Branch (434:10): [True: 527k, False: 415k] ------------------ 435| 527k| skip_number(ctx, it, end); 436| 527k| } 437| 943k| } 438| 943k| } 439| 943k| } _ZN3glz11skip_objectITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_EEvOT0_OT1_T2_: 29| 108k| { 30| | if constexpr (!check_validate_skipped(Opts)) { 31| | ++it; 32| | if constexpr (not Opts.null_terminated) { 33| | if (it == end) [[unlikely]] { 34| | ctx.error = error_code::unexpected_end; 35| | return; 36| | } 37| | } 38| | skip_until_closed(ctx, it, end); 39| | } 40| 108k| else { 41| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 42| | // released at each syntactic close below 43| 108k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (43:14): [True: 194, False: 108k] ------------------ 44| 194| return; 45| 194| } 46| 108k| ++it; 47| 108k| if constexpr (not Opts.null_terminated) { 48| 108k| if (it == end) [[unlikely]] { ------------------ | Branch (48:17): [True: 4, False: 108k] ------------------ 49| 4| ctx.error = error_code::unexpected_end; 50| 4| return; 51| 4| } 52| 108k| } 53| 108k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (53:14): [True: 15, False: 108k] ------------------ 54| 15| return; 55| 15| } 56| 108k| if (*it == '}') { ------------------ | Branch (56:14): [True: 1.70k, False: 106k] ------------------ 57| 1.70k| --ctx.depth; 58| 1.70k| ++it; 59| 1.70k| if constexpr (not Opts.null_terminated) { 60| 1.70k| if (it == end) { ------------------ | Branch (60:20): [True: 2, False: 1.69k] ------------------ 61| 2| ctx.error = error_code::end_reached; 62| 2| return; 63| 2| } 64| 1.70k| } 65| 1.69k| return; 66| 1.70k| } 67| 191k| while (true) { ------------------ | Branch (67:17): [True: 191k, Folded] ------------------ 68| 191k| if (*it != '"') { ------------------ | Branch (68:17): [True: 15.6k, False: 175k] ------------------ 69| 15.6k| ctx.error = error_code::syntax_error; 70| 15.6k| return; 71| 15.6k| } 72| 175k| skip_string(ctx, it, end); 73| 175k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (73:17): [True: 5.63k, False: 170k] ------------------ 74| 5.63k| return; 75| 170k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (75:17): [True: 67, False: 170k] ------------------ 76| 67| return; 77| 67| } 78| 170k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (78:17): [True: 7.17k, False: 163k] ------------------ 79| 7.17k| return; 80| 7.17k| } 81| 163k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (81:17): [True: 7, False: 162k] ------------------ 82| 7| return; 83| 7| } 84| 162k| skip_value::op(ctx, it, end); 85| 162k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (85:17): [True: 28.9k, False: 134k] ------------------ 86| 28.9k| return; 87| 134k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (87:17): [True: 113, False: 133k] ------------------ 88| 113| return; 89| 113| } 90| 133k| if (*it != ',') break; ------------------ | Branch (90:17): [True: 49.0k, False: 84.8k] ------------------ 91| 84.8k| ++it; 92| 84.8k| if constexpr (not Opts.null_terminated) { 93| 84.8k| if (it == end) [[unlikely]] { ------------------ | Branch (93:20): [True: 2, False: 84.8k] ------------------ 94| 2| ctx.error = error_code::unexpected_end; 95| 2| return; 96| 2| } 97| 84.8k| } 98| 84.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (98:17): [True: 4, False: 84.8k] ------------------ 99| 4| return; 100| 4| } 101| 84.8k| } 102| 49.0k| match<'}'>(ctx, it); 103| 49.0k| --ctx.depth; 104| 49.0k| if constexpr (not Opts.null_terminated) { 105| 49.0k| if (it == end) { ------------------ | Branch (105:17): [True: 28.3k, False: 20.6k] ------------------ 106| 28.3k| ctx.error = error_code::end_reached; 107| 28.3k| return; 108| 28.3k| } 109| 49.0k| } 110| 49.0k| } 111| 108k| } _ZN3glz10skip_arrayITnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS2_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS7_QooeqdtT_6formatL_ZNS_4JSONEEeqdtT_6formatL_ZNS_6NDJSONEEEEvOT0_OT1_T2_: 116| 205k| { 117| | if constexpr (!check_validate_skipped(Opts)) { 118| | ++it; 119| | if constexpr (not Opts.null_terminated) { 120| | if (it == end) [[unlikely]] { 121| | ctx.error = error_code::unexpected_end; 122| | return; 123| | } 124| | } 125| | skip_until_closed(ctx, it, end); 126| | } 127| 205k| else { 128| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 129| | // released at each syntactic close below 130| 205k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (130:14): [True: 304, False: 205k] ------------------ 131| 304| return; 132| 304| } 133| 205k| ++it; 134| 205k| if constexpr (not Opts.null_terminated) { 135| 205k| if (it == end) [[unlikely]] { ------------------ | Branch (135:17): [True: 3, False: 205k] ------------------ 136| 3| ctx.error = error_code::unexpected_end; 137| 3| return; 138| 3| } 139| 205k| } 140| 205k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (140:14): [True: 2, False: 205k] ------------------ 141| 2| return; 142| 2| } 143| 205k| if (*it == ']') { ------------------ | Branch (143:14): [True: 2.68k, False: 202k] ------------------ 144| 2.68k| --ctx.depth; 145| 2.68k| ++it; 146| 2.68k| if constexpr (not Opts.null_terminated) { 147| 2.68k| if (it == end) { ------------------ | Branch (147:20): [True: 837, False: 1.84k] ------------------ 148| 837| ctx.error = error_code::end_reached; 149| 837| return; 150| 837| } 151| 2.68k| } 152| 1.84k| return; 153| 2.68k| } 154| 527k| while (true) { ------------------ | Branch (154:17): [True: 527k, Folded] ------------------ 155| 527k| skip_value::op(ctx, it, end); 156| 527k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (156:17): [True: 181k, False: 345k] ------------------ 157| 181k| return; 158| 345k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (158:17): [True: 7, False: 345k] ------------------ 159| 7| return; 160| 7| } 161| 345k| if (*it != ',') break; ------------------ | Branch (161:17): [True: 20.6k, False: 324k] ------------------ 162| 324k| ++it; 163| 324k| if constexpr (not Opts.null_terminated) { 164| 324k| if (it == end) [[unlikely]] { ------------------ | Branch (164:20): [True: 1, False: 324k] ------------------ 165| 1| ctx.error = error_code::unexpected_end; 166| 1| return; 167| 1| } 168| 324k| } 169| 324k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (169:17): [True: 1, False: 324k] ------------------ 170| 1| return; 171| 1| } 172| 324k| } 173| 20.6k| match<']'>(ctx, it); 174| 20.6k| --ctx.depth; 175| 20.6k| if constexpr (not Opts.null_terminated) { 176| 20.6k| if (it == end) { ------------------ | Branch (176:17): [True: 377, False: 20.2k] ------------------ 177| 377| ctx.error = error_code::end_reached; 178| 377| return; 179| 377| } 180| 20.6k| } 181| 20.6k| } 182| 205k| } _ZN3glz11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEDaOT0_OT1_T2_: 312| 20.6k| { 313| 20.6k| auto start = it; 314| 20.6k| struct opts_validate_skipped : std::decay_t 315| 20.6k| { 316| 20.6k| bool validate_skipped = true; 317| 20.6k| }; 318| 20.6k| skip_value::op(ctx, it, end); 319| 20.6k| return std::span{start, size_t(it - start)}; 320| 20.6k| } _ZN3glz10skip_valueILj10EE2opITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS4_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES6_S9_S8_QntdtT_8commentsEEvSB_SD_SE_: 325| 47.1k| { 326| 47.1k| using namespace glz::detail; 327| | 328| | // Validating skips (parse_value/JSON pointer) require the full value in a 329| | // contiguous buffer, so streaming refill is not applied there. 330| | if constexpr (has_streaming_state && not check_validate_skipped(Opts)) { 331| | if (ctx.stream.enabled()) { 332| | skip_value_streaming(ctx, it, end); 333| | return; 334| | } 335| | } 336| | 337| | if constexpr (not check_validate_skipped(Opts)) { 338| | if constexpr (not check_ws_handled(Opts)) { 339| | if (skip_ws(ctx, it, end)) { 340| | return; 341| | } 342| | } 343| | while (true) { 344| | switch (*it) { 345| | case '{': 346| | ++it; 347| | if constexpr (not Opts.null_terminated) { 348| | if (it == end) [[unlikely]] { 349| | ctx.error = error_code::unexpected_end; 350| | return; 351| | } 352| | } 353| | skip_until_closed(ctx, it, end); 354| | if (bool(ctx.error)) [[unlikely]] 355| | return; 356| | break; 357| | case '[': 358| | ++it; 359| | if constexpr (not Opts.null_terminated) { 360| | if (it == end) [[unlikely]] { 361| | ctx.error = error_code::unexpected_end; 362| | return; 363| | } 364| | } 365| | skip_until_closed(ctx, it, end); 366| | if (bool(ctx.error)) [[unlikely]] 367| | return; 368| | break; 369| | case '"': 370| | skip_string(ctx, it, end); 371| | if (bool(ctx.error)) [[unlikely]] 372| | return; 373| | break; 374| | case ',': 375| | case '}': 376| | case ']': 377| | break; 378| | case '\0': 379| | ctx.error = error_code::unexpected_end; 380| | return; 381| | default: { 382| | ++it; 383| | if constexpr (not Opts.null_terminated) { 384| | if (it == end) [[unlikely]] { 385| | ctx.error = error_code::unexpected_end; 386| | return; 387| | } 388| | } 389| | continue; 390| | } 391| | } 392| | 393| | break; 394| | } 395| | } 396| 47.1k| else { 397| 47.1k| if constexpr (not check_ws_handled(Opts)) { 398| 47.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (398:17): [True: 0, False: 47.1k] ------------------ 399| 0| return; 400| 0| } 401| 47.1k| } 402| 47.1k| switch (*it) { 403| 5.89k| case '{': { ------------------ | Branch (403:10): [True: 5.89k, False: 41.2k] ------------------ 404| 5.89k| skip_object(ctx, it, end); 405| 5.89k| break; 406| 0| } 407| 4.09k| case '[': { ------------------ | Branch (407:10): [True: 4.09k, False: 43.0k] ------------------ 408| 4.09k| skip_array(ctx, it, end); 409| 4.09k| break; 410| 0| } 411| 9.57k| case '"': { ------------------ | Branch (411:10): [True: 9.57k, False: 37.5k] ------------------ 412| 9.57k| skip_string(ctx, it, end); 413| 9.57k| break; 414| 0| } 415| 802| case 'n': { ------------------ | Branch (415:10): [True: 802, False: 46.3k] ------------------ 416| 802| ++it; 417| 802| match<"ull", Opts>(ctx, it, end); 418| 802| break; 419| 0| } 420| 787| case 'f': { ------------------ | Branch (420:10): [True: 787, False: 46.3k] ------------------ 421| 787| ++it; 422| 787| match<"alse", Opts>(ctx, it, end); 423| 787| break; 424| 0| } 425| 972| case 't': { ------------------ | Branch (425:10): [True: 972, False: 46.1k] ------------------ 426| 972| ++it; 427| 972| match<"rue", Opts>(ctx, it, end); 428| 972| break; 429| 0| } 430| 0| case '\0': { ------------------ | Branch (430:10): [True: 0, False: 47.1k] ------------------ 431| 0| ctx.error = error_code::unexpected_end; 432| 0| break; 433| 0| } 434| 24.9k| default: { ------------------ | Branch (434:10): [True: 24.9k, False: 22.1k] ------------------ 435| 24.9k| skip_number(ctx, it, end); 436| 24.9k| } 437| 47.1k| } 438| 47.1k| } 439| 47.1k| } _ZN3glz11skip_objectITnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS6_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS2_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES4_S7_S6_EEvS9_SB_SC_: 29| 5.89k| { 30| | if constexpr (!check_validate_skipped(Opts)) { 31| | ++it; 32| | if constexpr (not Opts.null_terminated) { 33| | if (it == end) [[unlikely]] { 34| | ctx.error = error_code::unexpected_end; 35| | return; 36| | } 37| | } 38| | skip_until_closed(ctx, it, end); 39| | } 40| 5.89k| else { 41| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 42| | // released at each syntactic close below 43| 5.89k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (43:14): [True: 0, False: 5.89k] ------------------ 44| 0| return; 45| 0| } 46| 5.89k| ++it; 47| 5.89k| if constexpr (not Opts.null_terminated) { 48| 5.89k| if (it == end) [[unlikely]] { ------------------ | Branch (48:17): [True: 0, False: 5.89k] ------------------ 49| 0| ctx.error = error_code::unexpected_end; 50| 0| return; 51| 0| } 52| 5.89k| } 53| 5.89k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (53:14): [True: 0, False: 5.89k] ------------------ 54| 0| return; 55| 0| } 56| 5.89k| if (*it == '}') { ------------------ | Branch (56:14): [True: 619, False: 5.27k] ------------------ 57| 619| --ctx.depth; 58| 619| ++it; 59| 619| if constexpr (not Opts.null_terminated) { 60| 619| if (it == end) { ------------------ | Branch (60:20): [True: 0, False: 619] ------------------ 61| 0| ctx.error = error_code::end_reached; 62| 0| return; 63| 0| } 64| 619| } 65| 619| return; 66| 619| } 67| 13.9k| while (true) { ------------------ | Branch (67:17): [True: 13.9k, Folded] ------------------ 68| 13.9k| if (*it != '"') { ------------------ | Branch (68:17): [True: 0, False: 13.9k] ------------------ 69| 0| ctx.error = error_code::syntax_error; 70| 0| return; 71| 0| } 72| 13.9k| skip_string(ctx, it, end); 73| 13.9k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (73:17): [True: 0, False: 13.9k] ------------------ 74| 0| return; 75| 13.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (75:17): [True: 0, False: 13.9k] ------------------ 76| 0| return; 77| 0| } 78| 13.9k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (78:17): [True: 0, False: 13.9k] ------------------ 79| 0| return; 80| 0| } 81| 13.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (81:17): [True: 0, False: 13.9k] ------------------ 82| 0| return; 83| 0| } 84| 13.9k| skip_value::op(ctx, it, end); 85| 13.9k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (85:17): [True: 0, False: 13.9k] ------------------ 86| 0| return; 87| 13.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (87:17): [True: 0, False: 13.9k] ------------------ 88| 0| return; 89| 0| } 90| 13.9k| if (*it != ',') break; ------------------ | Branch (90:17): [True: 5.27k, False: 8.62k] ------------------ 91| 8.62k| ++it; 92| 8.62k| if constexpr (not Opts.null_terminated) { 93| 8.62k| if (it == end) [[unlikely]] { ------------------ | Branch (93:20): [True: 0, False: 8.62k] ------------------ 94| 0| ctx.error = error_code::unexpected_end; 95| 0| return; 96| 0| } 97| 8.62k| } 98| 8.62k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (98:17): [True: 0, False: 8.62k] ------------------ 99| 0| return; 100| 0| } 101| 8.62k| } 102| 5.27k| match<'}'>(ctx, it); 103| 5.27k| --ctx.depth; 104| 5.27k| if constexpr (not Opts.null_terminated) { 105| 5.27k| if (it == end) { ------------------ | Branch (105:17): [True: 0, False: 5.27k] ------------------ 106| 0| ctx.error = error_code::end_reached; 107| 0| return; 108| 0| } 109| 5.27k| } 110| 5.27k| } 111| 5.89k| } _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_: 116| 4.09k| { 117| | if constexpr (!check_validate_skipped(Opts)) { 118| | ++it; 119| | if constexpr (not Opts.null_terminated) { 120| | if (it == end) [[unlikely]] { 121| | ctx.error = error_code::unexpected_end; 122| | return; 123| | } 124| | } 125| | skip_until_closed(ctx, it, end); 126| | } 127| 4.09k| else { 128| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 129| | // released at each syntactic close below 130| 4.09k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (130:14): [True: 0, False: 4.09k] ------------------ 131| 0| return; 132| 0| } 133| 4.09k| ++it; 134| 4.09k| if constexpr (not Opts.null_terminated) { 135| 4.09k| if (it == end) [[unlikely]] { ------------------ | Branch (135:17): [True: 0, False: 4.09k] ------------------ 136| 0| ctx.error = error_code::unexpected_end; 137| 0| return; 138| 0| } 139| 4.09k| } 140| 4.09k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (140:14): [True: 0, False: 4.09k] ------------------ 141| 0| return; 142| 0| } 143| 4.09k| if (*it == ']') { ------------------ | Branch (143:14): [True: 391, False: 3.70k] ------------------ 144| 391| --ctx.depth; 145| 391| ++it; 146| 391| if constexpr (not Opts.null_terminated) { 147| 391| if (it == end) { ------------------ | Branch (147:20): [True: 0, False: 391] ------------------ 148| 0| ctx.error = error_code::end_reached; 149| 0| return; 150| 0| } 151| 391| } 152| 391| return; 153| 391| } 154| 12.5k| while (true) { ------------------ | Branch (154:17): [True: 12.5k, Folded] ------------------ 155| 12.5k| skip_value::op(ctx, it, end); 156| 12.5k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (156:17): [True: 0, False: 12.5k] ------------------ 157| 0| return; 158| 12.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (158:17): [True: 0, False: 12.5k] ------------------ 159| 0| return; 160| 0| } 161| 12.5k| if (*it != ',') break; ------------------ | Branch (161:17): [True: 3.70k, False: 8.83k] ------------------ 162| 8.83k| ++it; 163| 8.83k| if constexpr (not Opts.null_terminated) { 164| 8.83k| if (it == end) [[unlikely]] { ------------------ | Branch (164:20): [True: 0, False: 8.83k] ------------------ 165| 0| ctx.error = error_code::unexpected_end; 166| 0| return; 167| 0| } 168| 8.83k| } 169| 8.83k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (169:17): [True: 0, False: 8.83k] ------------------ 170| 0| return; 171| 0| } 172| 8.83k| } 173| 3.70k| match<']'>(ctx, it); 174| 3.70k| --ctx.depth; 175| 3.70k| if constexpr (not Opts.null_terminated) { 176| 3.70k| if (it == end) { ------------------ | Branch (176:17): [True: 0, False: 3.70k] ------------------ 177| 0| ctx.error = error_code::end_reached; 178| 0| return; 179| 0| } 180| 3.70k| } 181| 3.70k| } 182| 4.09k| } _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_: 2843| 45.1k| { 2844| 45.1k| return write(std::forward(value)); 2845| 45.1k| } _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 45.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| 45.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| 45.1k| else { 945| 45.1k| const sv str = [&]() -> const sv { 946| 45.1k| if constexpr (array_char_t) { 947| 45.1k| return sv{value.data(), value.size()}; 948| 45.1k| } 949| 45.1k| else if constexpr (u8str_t) { 950| 45.1k| return sv{reinterpret_cast(value.data()), value.size()}; 951| 45.1k| } 952| 45.1k| else { 953| 45.1k| return str_view(value); 954| 45.1k| } 955| 45.1k| }(); 956| 45.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| 45.1k| else { 988| | // Using the original sizing 989| 45.1k| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 45.1k] ------------------ 990| 0| return; 991| 0| } 992| 45.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| 45.1k| else { 1002| 45.1k| std::memcpy(&b[ix], "\"", 1); 1003| 45.1k| ++ix; 1004| | 1005| 45.1k| const auto* c = str.data(); 1006| 45.1k| const auto* const e = c + n; 1007| 45.1k| const auto start = &b[ix]; 1008| 45.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| 45.1k| auto write_escape = [&]() { 1017| 45.1k| if constexpr (check_escape_control_characters(Opts)) { 1018| 45.1k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 45.1k| std::memcpy(data, &escaped, 2); 1020| 45.1k| data += 2; 1021| 45.1k| } 1022| 45.1k| else { 1023| 45.1k| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 45.1k| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 45.1k| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 45.1k| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 45.1k| std::memcpy(data, unicode_escape, 6); 1028| 45.1k| data += 6; 1029| 45.1k| } 1030| 45.1k| } 1031| 45.1k| else { 1032| 45.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| 45.1k| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 45.1k| ctx.error = error_code::invalid_control_character; 1040| 45.1k| } 1041| 45.1k| } 1042| 45.1k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 45.1k| data += 2; 1044| 45.1k| } 1045| 45.1k| ++c; 1046| 45.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| 45.1k|#if defined(GLZ_USE_SSE2) 1055| 45.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| 45.1k| if (n > 7) { ------------------ | Branch (1061:23): [True: 45.1k, False: 0] ------------------ 1062| 88.0k| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 42.9k, False: 45.1k] ------------------ 1063| 42.9k| std::memcpy(data, c, 8); 1064| 42.9k| uint64_t swar; 1065| 42.9k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 42.9k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 42.9k| const uint64_t lo7 = swar & lo7_mask; 1072| 42.9k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 42.9k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 42.9k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 42.9k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 42.9k| next &= repeat_byte8(0b10000000); 1078| 42.9k| if (next == 0) { ------------------ | Branch (1078:29): [True: 30.4k, False: 12.4k] ------------------ 1079| 30.4k| data += 8; 1080| 30.4k| c += 8; 1081| 30.4k| continue; 1082| 30.4k| } 1083| | 1084| 12.4k| const auto length = (countr_zero(next) >> 3); 1085| 12.4k| c += length; 1086| 12.4k| data += length; 1087| 12.4k| write_escape(); 1088| 12.4k| } 1089| 45.1k| } 1090| | 1091| | // Scalar tail 1092| 215k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 169k, False: 45.1k] ------------------ 1093| 169k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 2.60k, False: 167k] ------------------ 1094| 2.60k| std::memcpy(data, &escaped, 2); 1095| 2.60k| data += 2; 1096| 2.60k| } 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| 167k| 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| 167k| std::memcpy(data, c, 1); 1118| 167k| ++data; 1119| 167k| } 1120| 169k| } 1121| | 1122| 45.1k| ix += size_t(data - start); 1123| | 1124| 45.1k| std::memcpy(&b[ix], "\"", 1); 1125| 45.1k| ++ix; 1126| 45.1k| } 1127| 45.1k| } 1128| 45.1k| } 1129| 45.1k| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 45.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| 45.1k| else { 953| 45.1k| return str_view(value); 954| 45.1k| } 955| 45.1k| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_RKS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 9.73M| 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| 9.73M| 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| 9.73M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 9.73M| data += 2; 1044| 9.73M| } 1045| 9.73M| ++c; 1046| 9.73M| }; _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERNSt3__17variantIJDnNS2_17basic_string_viewIcNS2_11char_traitsIcEEEElEEEEENS2_8expectedINS2_12basic_stringIcS6_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_: 2843| 44.7k| { 2844| 44.7k| return write(std::forward(value)); 2845| 44.7k| } _ZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1955| 44.7k| { 1956| | // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are 1957| | // written side by side whatever the alternative is. The visit below still instantiates in 1958| | // that mode (`if constexpr` does not discard the statements after it), but both of its 1959| | // tagged branches are compile-time dead there and the runtime `return` keeps it unreached. 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) { 1961| | write_adjacent(value, ctx, b, ix); 1962| | return; 1963| | } 1964| 44.7k| std::visit( 1965| 44.7k| [&](auto&& val) { 1966| 44.7k| using V = std::decay_t; 1967| | 1968| 44.7k| if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| 44.7k| custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| 44.7k| if (missing_id(value, ctx)) { 1980| 44.7k| return; 1981| 44.7k| } 1982| 44.7k| using id_type = std::decay_t[value.index()])>; 1983| 44.7k| if constexpr (Opts.prettify) { 1984| 44.7k| dump("{\n", b, ix); 1985| 44.7k| ctx.depth += check_indentation_width(Opts); 1986| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| 44.7k| dump('"', b, ix); 1988| 44.7k| dump_maybe_empty(tag_v, b, ix); 1989| 44.7k| if constexpr (std::integral) { 1990| 44.7k| dump("\": ", b, ix); 1991| 44.7k| serialize::op(ids_v[value.index()], ctx, b, ix); 1992| 44.7k| } 1993| 44.7k| else { 1994| 44.7k| dump("\": \"", b, ix); 1995| 44.7k| dump_maybe_empty(ids_v[value.index()], b, ix); 1996| 44.7k| dump('"', b, ix); 1997| 44.7k| } 1998| 44.7k| const auto pos_after_tag = ix; 1999| 44.7k| dump(",\n", b, ix); 2000| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| 44.7k| const auto pos_body_start = ix; 2002| 44.7k| to::template op()>(val, ctx, b, ix); 2003| 44.7k| if (ix == pos_body_start) { 2004| 44.7k| ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| 44.7k| } 2006| 44.7k| ctx.depth -= check_indentation_width(Opts); 2007| 44.7k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| 44.7k| return; 2009| 44.7k| } 2010| 44.7k| std::memcpy(&b[ix], "\n", 1); 2011| 44.7k| ++ix; 2012| 44.7k| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| 44.7k| ix += ctx.depth; 2014| 44.7k| std::memcpy(&b[ix], "}", 1); 2015| 44.7k| ++ix; 2016| 44.7k| } 2017| 44.7k| else { 2018| 44.7k| dump("{\"", b, ix); 2019| 44.7k| dump_maybe_empty(tag_v, b, ix); 2020| 44.7k| if constexpr (std::integral) { 2021| 44.7k| dump("\":", b, ix); 2022| 44.7k| serialize::op(ids_v[value.index()], ctx, b, ix); 2023| 44.7k| } 2024| 44.7k| else { 2025| 44.7k| dump("\":\"", b, ix); 2026| 44.7k| dump_maybe_empty(ids_v[value.index()], b, ix); 2027| 44.7k| dump('"', b, ix); 2028| 44.7k| } 2029| 44.7k| const auto pos_after_tag = ix; 2030| 44.7k| dump(',', b, ix); 2031| 44.7k| const auto pos_body_start = ix; 2032| 44.7k| to::template op()>(val, ctx, b, ix); 2033| 44.7k| if (ix == pos_body_start) { 2034| 44.7k| ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| 44.7k| } 2036| 44.7k| dump('}', b, ix); 2037| 44.7k| } 2038| 44.7k| } 2039| 44.7k| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| 44.7k| variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| 44.7k| if (missing_id(value, ctx)) { 2044| 44.7k| return; 2045| 44.7k| } 2046| 44.7k| if constexpr (Opts.prettify) { 2047| 44.7k| dump("{\n", b, ix); 2048| 44.7k| ctx.depth += check_indentation_width(Opts); 2049| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| 44.7k| dump('"', b, ix); 2051| 44.7k| dump_maybe_empty(tag_v, b, ix); 2052| 44.7k| dump("\": ", b, ix); 2053| 44.7k| write_id(value, ctx, b, ix); 2054| 44.7k| ctx.depth -= check_indentation_width(Opts); 2055| 44.7k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| 44.7k| return; 2057| 44.7k| } 2058| 44.7k| std::memcpy(&b[ix], "\n", 1); 2059| 44.7k| ++ix; 2060| 44.7k| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| 44.7k| ix += ctx.depth; 2062| 44.7k| std::memcpy(&b[ix], "}", 1); 2063| 44.7k| ++ix; 2064| 44.7k| } 2065| 44.7k| else { 2066| 44.7k| dump("{\"", b, ix); 2067| 44.7k| dump_maybe_empty(tag_v, b, ix); 2068| 44.7k| dump("\":", b, ix); 2069| 44.7k| write_id(value, ctx, b, ix); 2070| 44.7k| dump('}', b, ix); 2071| 44.7k| } 2072| 44.7k| } 2073| 44.7k| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| 44.7k| (glaze_object_t || reflectable || is_memory_object) && 2075| 44.7k| (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| 44.7k| if (missing_id(value, ctx)) { 2081| 44.7k| return; 2082| 44.7k| } 2083| 44.7k| constexpr auto N = []() { 2084| 44.7k| if constexpr (is_memory_object) { 2085| 44.7k| return reflect>::size; 2086| 44.7k| } 2087| 44.7k| else { 2088| 44.7k| return reflect::size; 2089| 44.7k| } 2090| 44.7k| }(); 2091| | 2092| | // must first write out type 2093| 44.7k| if constexpr (Opts.prettify) { 2094| 44.7k| dump("{\n", b, ix); 2095| 44.7k| ctx.depth += check_indentation_width(Opts); 2096| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| 44.7k| dump('"', b, ix); 2098| 44.7k| dump_maybe_empty(tag_v, b, ix); 2099| | 2100| 44.7k| using id_type = std::decay_t[value.index()])>; 2101| | 2102| 44.7k| if constexpr (std::integral) { 2103| 44.7k| dump("\": ", b, ix); 2104| 44.7k| serialize::op(ids_v[value.index()], ctx, b, ix); 2105| 44.7k| if constexpr (N > 0) { 2106| 44.7k| dump(",\n", b, ix); 2107| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| 44.7k| } 2109| 44.7k| } 2110| 44.7k| else { 2111| 44.7k| dump("\": \"", b, ix); 2112| 44.7k| dump_maybe_empty(ids_v[value.index()], b, ix); 2113| 44.7k| if constexpr (N == 0) { 2114| 44.7k| dump('"', b, ix); 2115| 44.7k| } 2116| 44.7k| else { 2117| 44.7k| dump("\",\n", b, ix); 2118| 44.7k| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| 44.7k| } 2120| 44.7k| } 2121| 44.7k| } 2122| 44.7k| else { 2123| 44.7k| using id_type = std::decay_t[value.index()])>; 2124| | 2125| 44.7k| dump("{\"", b, ix); 2126| 44.7k| dump_maybe_empty(tag_v, b, ix); 2127| | 2128| 44.7k| if constexpr (std::integral) { 2129| 44.7k| dump("\":", b, ix); 2130| 44.7k| serialize::op(ids_v[value.index()], ctx, b, ix); 2131| 44.7k| if constexpr (N > 0) { 2132| 44.7k| dump(',', b, ix); 2133| 44.7k| } 2134| 44.7k| } 2135| 44.7k| else { 2136| 44.7k| dump("\":\"", b, ix); 2137| 44.7k| dump_maybe_empty(ids_v[value.index()], b, ix); 2138| 44.7k| if constexpr (N == 0) { 2139| 44.7k| dump('"', b, ix); 2140| 44.7k| } 2141| 44.7k| else { 2142| 44.7k| dump("\",", b, ix); 2143| 44.7k| } 2144| 44.7k| } 2145| 44.7k| } 2146| 44.7k| if constexpr (is_memory_object) { 2147| 44.7k| if (!val) [[unlikely]] { 2148| 44.7k| ctx.error = error_code::invalid_variant_object; 2149| 44.7k| return; 2150| 44.7k| } 2151| 44.7k| to>::template op()>(*val, ctx, b, ix); 2152| 44.7k| } 2153| 44.7k| else { 2154| 44.7k| to::template op()>(val, ctx, b, ix); 2155| 44.7k| } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| 44.7k| if constexpr (Opts.skip_null_members) { 2158| 44.7k| if (b[ix - 1] == ',') { 2159| 44.7k| --ix; 2160| 44.7k| } 2161| 44.7k| } 2162| | 2163| 44.7k| if constexpr (Opts.prettify) { 2164| 44.7k| ctx.depth -= check_indentation_width(Opts); 2165| 44.7k| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| 44.7k| return; 2167| 44.7k| } 2168| 44.7k| std::memcpy(&b[ix], "\n", 1); 2169| 44.7k| ++ix; 2170| 44.7k| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| 44.7k| ix += ctx.depth; 2172| 44.7k| std::memcpy(&b[ix], "}", 1); 2173| 44.7k| ++ix; 2174| 44.7k| } 2175| 44.7k| else { 2176| 44.7k| dump('}', b, ix); 2177| 44.7k| } 2178| 44.7k| } 2179| 44.7k| else { 2180| 44.7k| to::template op(val, ctx, b, ix); 2181| 44.7k| } 2182| 44.7k| }, 2183| 44.7k| value); 2184| 44.7k| } _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRDnEEDaSS_: 1965| 5.65k| [&](auto&& val) { 1966| 5.65k| using V = std::decay_t; 1967| | 1968| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| | custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| | if (missing_id(value, ctx)) { 1980| | return; 1981| | } 1982| | using id_type = std::decay_t[value.index()])>; 1983| | if constexpr (Opts.prettify) { 1984| | dump("{\n", b, ix); 1985| | ctx.depth += check_indentation_width(Opts); 1986| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| | dump('"', b, ix); 1988| | dump_maybe_empty(tag_v, b, ix); 1989| | if constexpr (std::integral) { 1990| | dump("\": ", b, ix); 1991| | serialize::op(ids_v[value.index()], ctx, b, ix); 1992| | } 1993| | else { 1994| | dump("\": \"", b, ix); 1995| | dump_maybe_empty(ids_v[value.index()], b, ix); 1996| | dump('"', b, ix); 1997| | } 1998| | const auto pos_after_tag = ix; 1999| | dump(",\n", b, ix); 2000| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| | const auto pos_body_start = ix; 2002| | to::template op()>(val, ctx, b, ix); 2003| | if (ix == pos_body_start) { 2004| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| | } 2006| | ctx.depth -= check_indentation_width(Opts); 2007| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| | return; 2009| | } 2010| | std::memcpy(&b[ix], "\n", 1); 2011| | ++ix; 2012| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| | ix += ctx.depth; 2014| | std::memcpy(&b[ix], "}", 1); 2015| | ++ix; 2016| | } 2017| | else { 2018| | dump("{\"", b, ix); 2019| | dump_maybe_empty(tag_v, b, ix); 2020| | if constexpr (std::integral) { 2021| | dump("\":", b, ix); 2022| | serialize::op(ids_v[value.index()], ctx, b, ix); 2023| | } 2024| | else { 2025| | dump("\":\"", b, ix); 2026| | dump_maybe_empty(ids_v[value.index()], b, ix); 2027| | dump('"', b, ix); 2028| | } 2029| | const auto pos_after_tag = ix; 2030| | dump(',', b, ix); 2031| | const auto pos_body_start = ix; 2032| | to::template op()>(val, ctx, b, ix); 2033| | if (ix == pos_body_start) { 2034| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| | } 2036| | dump('}', b, ix); 2037| | } 2038| | } 2039| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| | variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| | if (missing_id(value, ctx)) { 2044| | return; 2045| | } 2046| | if constexpr (Opts.prettify) { 2047| | dump("{\n", b, ix); 2048| | ctx.depth += check_indentation_width(Opts); 2049| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| | dump('"', b, ix); 2051| | dump_maybe_empty(tag_v, b, ix); 2052| | dump("\": ", b, ix); 2053| | write_id(value, ctx, b, ix); 2054| | ctx.depth -= check_indentation_width(Opts); 2055| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| | return; 2057| | } 2058| | std::memcpy(&b[ix], "\n", 1); 2059| | ++ix; 2060| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| | ix += ctx.depth; 2062| | std::memcpy(&b[ix], "}", 1); 2063| | ++ix; 2064| | } 2065| | else { 2066| | dump("{\"", b, ix); 2067| | dump_maybe_empty(tag_v, b, ix); 2068| | dump("\":", b, ix); 2069| | write_id(value, ctx, b, ix); 2070| | dump('}', b, ix); 2071| | } 2072| | } 2073| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| | (glaze_object_t || reflectable || is_memory_object) && 2075| | (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| | if (missing_id(value, ctx)) { 2081| | return; 2082| | } 2083| | constexpr auto N = []() { 2084| | if constexpr (is_memory_object) { 2085| | return reflect>::size; 2086| | } 2087| | else { 2088| | return reflect::size; 2089| | } 2090| | }(); 2091| | 2092| | // must first write out type 2093| | if constexpr (Opts.prettify) { 2094| | dump("{\n", b, ix); 2095| | ctx.depth += check_indentation_width(Opts); 2096| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| | dump('"', b, ix); 2098| | dump_maybe_empty(tag_v, b, ix); 2099| | 2100| | using id_type = std::decay_t[value.index()])>; 2101| | 2102| | if constexpr (std::integral) { 2103| | dump("\": ", b, ix); 2104| | serialize::op(ids_v[value.index()], ctx, b, ix); 2105| | if constexpr (N > 0) { 2106| | dump(",\n", b, ix); 2107| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| | } 2109| | } 2110| | else { 2111| | dump("\": \"", b, ix); 2112| | dump_maybe_empty(ids_v[value.index()], b, ix); 2113| | if constexpr (N == 0) { 2114| | dump('"', b, ix); 2115| | } 2116| | else { 2117| | dump("\",\n", b, ix); 2118| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| | } 2120| | } 2121| | } 2122| | else { 2123| | using id_type = std::decay_t[value.index()])>; 2124| | 2125| | dump("{\"", b, ix); 2126| | dump_maybe_empty(tag_v, b, ix); 2127| | 2128| | if constexpr (std::integral) { 2129| | dump("\":", b, ix); 2130| | serialize::op(ids_v[value.index()], ctx, b, ix); 2131| | if constexpr (N > 0) { 2132| | dump(',', b, ix); 2133| | } 2134| | } 2135| | else { 2136| | dump("\":\"", b, ix); 2137| | dump_maybe_empty(ids_v[value.index()], b, ix); 2138| | if constexpr (N == 0) { 2139| | dump('"', b, ix); 2140| | } 2141| | else { 2142| | dump("\",", b, ix); 2143| | } 2144| | } 2145| | } 2146| | if constexpr (is_memory_object) { 2147| | if (!val) [[unlikely]] { 2148| | ctx.error = error_code::invalid_variant_object; 2149| | return; 2150| | } 2151| | to>::template op()>(*val, ctx, b, ix); 2152| | } 2153| | else { 2154| | to::template op()>(val, ctx, b, ix); 2155| | } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| | if constexpr (Opts.skip_null_members) { 2158| | if (b[ix - 1] == ',') { 2159| | --ix; 2160| | } 2161| | } 2162| | 2163| | if constexpr (Opts.prettify) { 2164| | ctx.depth -= check_indentation_width(Opts); 2165| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| | return; 2167| | } 2168| | std::memcpy(&b[ix], "\n", 1); 2169| | ++ix; 2170| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| | ix += ctx.depth; 2172| | std::memcpy(&b[ix], "}", 1); 2173| | ++ix; 2174| | } 2175| | else { 2176| | dump('}', b, ix); 2177| | } 2178| | } 2179| 5.65k| else { 2180| 5.65k| to::template op(val, ctx, b, ix); 2181| 5.65k| } 2182| 5.65k| }, _ZN3glz2toILj10EDnE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERDnTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1849| 5.65k| { 1850| 5.65k| if constexpr (not check_write_unchecked(Opts)) { 1851| 5.65k| if (!ensure_space(ctx, b, ix + 4)) [[unlikely]] { ------------------ | Branch (1851:17): [True: 0, False: 5.65k] ------------------ 1852| 0| return; 1853| 0| } 1854| 5.65k| } 1855| | if constexpr (std::endian::native == std::endian::big) { 1856| | static constexpr char null_v[] = "null"; 1857| | std::memcpy(&b[ix], null_v, 4); 1858| | } 1859| 5.65k| else { 1860| 5.65k| static constexpr uint32_t null_v = 1819047278; 1861| 5.65k| std::memcpy(&b[ix], &null_v, 4); 1862| 5.65k| } 1863| 5.65k| ix += 4; 1864| 5.65k| } _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRS6_EEDaSS_: 1965| 5.88k| [&](auto&& val) { 1966| 5.88k| using V = std::decay_t; 1967| | 1968| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| | custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| | if (missing_id(value, ctx)) { 1980| | return; 1981| | } 1982| | using id_type = std::decay_t[value.index()])>; 1983| | if constexpr (Opts.prettify) { 1984| | dump("{\n", b, ix); 1985| | ctx.depth += check_indentation_width(Opts); 1986| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| | dump('"', b, ix); 1988| | dump_maybe_empty(tag_v, b, ix); 1989| | if constexpr (std::integral) { 1990| | dump("\": ", b, ix); 1991| | serialize::op(ids_v[value.index()], ctx, b, ix); 1992| | } 1993| | else { 1994| | dump("\": \"", b, ix); 1995| | dump_maybe_empty(ids_v[value.index()], b, ix); 1996| | dump('"', b, ix); 1997| | } 1998| | const auto pos_after_tag = ix; 1999| | dump(",\n", b, ix); 2000| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| | const auto pos_body_start = ix; 2002| | to::template op()>(val, ctx, b, ix); 2003| | if (ix == pos_body_start) { 2004| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| | } 2006| | ctx.depth -= check_indentation_width(Opts); 2007| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| | return; 2009| | } 2010| | std::memcpy(&b[ix], "\n", 1); 2011| | ++ix; 2012| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| | ix += ctx.depth; 2014| | std::memcpy(&b[ix], "}", 1); 2015| | ++ix; 2016| | } 2017| | else { 2018| | dump("{\"", b, ix); 2019| | dump_maybe_empty(tag_v, b, ix); 2020| | if constexpr (std::integral) { 2021| | dump("\":", b, ix); 2022| | serialize::op(ids_v[value.index()], ctx, b, ix); 2023| | } 2024| | else { 2025| | dump("\":\"", b, ix); 2026| | dump_maybe_empty(ids_v[value.index()], b, ix); 2027| | dump('"', b, ix); 2028| | } 2029| | const auto pos_after_tag = ix; 2030| | dump(',', b, ix); 2031| | const auto pos_body_start = ix; 2032| | to::template op()>(val, ctx, b, ix); 2033| | if (ix == pos_body_start) { 2034| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| | } 2036| | dump('}', b, ix); 2037| | } 2038| | } 2039| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| | variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| | if (missing_id(value, ctx)) { 2044| | return; 2045| | } 2046| | if constexpr (Opts.prettify) { 2047| | dump("{\n", b, ix); 2048| | ctx.depth += check_indentation_width(Opts); 2049| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| | dump('"', b, ix); 2051| | dump_maybe_empty(tag_v, b, ix); 2052| | dump("\": ", b, ix); 2053| | write_id(value, ctx, b, ix); 2054| | ctx.depth -= check_indentation_width(Opts); 2055| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| | return; 2057| | } 2058| | std::memcpy(&b[ix], "\n", 1); 2059| | ++ix; 2060| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| | ix += ctx.depth; 2062| | std::memcpy(&b[ix], "}", 1); 2063| | ++ix; 2064| | } 2065| | else { 2066| | dump("{\"", b, ix); 2067| | dump_maybe_empty(tag_v, b, ix); 2068| | dump("\":", b, ix); 2069| | write_id(value, ctx, b, ix); 2070| | dump('}', b, ix); 2071| | } 2072| | } 2073| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| | (glaze_object_t || reflectable || is_memory_object) && 2075| | (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| | if (missing_id(value, ctx)) { 2081| | return; 2082| | } 2083| | constexpr auto N = []() { 2084| | if constexpr (is_memory_object) { 2085| | return reflect>::size; 2086| | } 2087| | else { 2088| | return reflect::size; 2089| | } 2090| | }(); 2091| | 2092| | // must first write out type 2093| | if constexpr (Opts.prettify) { 2094| | dump("{\n", b, ix); 2095| | ctx.depth += check_indentation_width(Opts); 2096| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| | dump('"', b, ix); 2098| | dump_maybe_empty(tag_v, b, ix); 2099| | 2100| | using id_type = std::decay_t[value.index()])>; 2101| | 2102| | if constexpr (std::integral) { 2103| | dump("\": ", b, ix); 2104| | serialize::op(ids_v[value.index()], ctx, b, ix); 2105| | if constexpr (N > 0) { 2106| | dump(",\n", b, ix); 2107| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| | } 2109| | } 2110| | else { 2111| | dump("\": \"", b, ix); 2112| | dump_maybe_empty(ids_v[value.index()], b, ix); 2113| | if constexpr (N == 0) { 2114| | dump('"', b, ix); 2115| | } 2116| | else { 2117| | dump("\",\n", b, ix); 2118| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| | } 2120| | } 2121| | } 2122| | else { 2123| | using id_type = std::decay_t[value.index()])>; 2124| | 2125| | dump("{\"", b, ix); 2126| | dump_maybe_empty(tag_v, b, ix); 2127| | 2128| | if constexpr (std::integral) { 2129| | dump("\":", b, ix); 2130| | serialize::op(ids_v[value.index()], ctx, b, ix); 2131| | if constexpr (N > 0) { 2132| | dump(',', b, ix); 2133| | } 2134| | } 2135| | else { 2136| | dump("\":\"", b, ix); 2137| | dump_maybe_empty(ids_v[value.index()], b, ix); 2138| | if constexpr (N == 0) { 2139| | dump('"', b, ix); 2140| | } 2141| | else { 2142| | dump("\",", b, ix); 2143| | } 2144| | } 2145| | } 2146| | if constexpr (is_memory_object) { 2147| | if (!val) [[unlikely]] { 2148| | ctx.error = error_code::invalid_variant_object; 2149| | return; 2150| | } 2151| | to>::template op()>(*val, ctx, b, ix); 2152| | } 2153| | else { 2154| | to::template op()>(val, ctx, b, ix); 2155| | } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| | if constexpr (Opts.skip_null_members) { 2158| | if (b[ix - 1] == ',') { 2159| | --ix; 2160| | } 2161| | } 2162| | 2163| | if constexpr (Opts.prettify) { 2164| | ctx.depth -= check_indentation_width(Opts); 2165| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| | return; 2167| | } 2168| | std::memcpy(&b[ix], "\n", 1); 2169| | ++ix; 2170| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| | ix += ctx.depth; 2172| | std::memcpy(&b[ix], "}", 1); 2173| | ++ix; 2174| | } 2175| | else { 2176| | dump('}', b, ix); 2177| | } 2178| | } 2179| 5.88k| else { 2180| 5.88k| to::template op(val, ctx, b, ix); 2181| 5.88k| } 2182| 5.88k| }, _ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 5.88k| { 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.88k| 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.88k| else { 945| 5.88k| const sv str = [&]() -> const sv { 946| 5.88k| if constexpr (array_char_t) { 947| 5.88k| return sv{value.data(), value.size()}; 948| 5.88k| } 949| 5.88k| else if constexpr (u8str_t) { 950| 5.88k| return sv{reinterpret_cast(value.data()), value.size()}; 951| 5.88k| } 952| 5.88k| else { 953| 5.88k| return str_view(value); 954| 5.88k| } 955| 5.88k| }(); 956| 5.88k| 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.88k| else { 988| | // Using the original sizing 989| 5.88k| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 5.88k] ------------------ 990| 0| return; 991| 0| } 992| 5.88k| } 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.88k| else { 1002| 5.88k| std::memcpy(&b[ix], "\"", 1); 1003| 5.88k| ++ix; 1004| | 1005| 5.88k| const auto* c = str.data(); 1006| 5.88k| const auto* const e = c + n; 1007| 5.88k| const auto start = &b[ix]; 1008| 5.88k| 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.88k| auto write_escape = [&]() { 1017| 5.88k| if constexpr (check_escape_control_characters(Opts)) { 1018| 5.88k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 5.88k| std::memcpy(data, &escaped, 2); 1020| 5.88k| data += 2; 1021| 5.88k| } 1022| 5.88k| else { 1023| 5.88k| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 5.88k| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 5.88k| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 5.88k| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 5.88k| std::memcpy(data, unicode_escape, 6); 1028| 5.88k| data += 6; 1029| 5.88k| } 1030| 5.88k| } 1031| 5.88k| else { 1032| 5.88k| 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.88k| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 5.88k| ctx.error = error_code::invalid_control_character; 1040| 5.88k| } 1041| 5.88k| } 1042| 5.88k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 5.88k| data += 2; 1044| 5.88k| } 1045| 5.88k| ++c; 1046| 5.88k| }; 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.88k|#if defined(GLZ_USE_SSE2) 1055| 5.88k| 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.88k| if (n > 7) { ------------------ | Branch (1061:23): [True: 3.65k, False: 2.22k] ------------------ 1062| 14.3k| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 10.6k, False: 3.65k] ------------------ 1063| 10.6k| std::memcpy(data, c, 8); 1064| 10.6k| uint64_t swar; 1065| 10.6k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 10.6k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 10.6k| const uint64_t lo7 = swar & lo7_mask; 1072| 10.6k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 10.6k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 10.6k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 10.6k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 10.6k| next &= repeat_byte8(0b10000000); 1078| 10.6k| if (next == 0) { ------------------ | Branch (1078:29): [True: 1.12k, False: 9.51k] ------------------ 1079| 1.12k| data += 8; 1080| 1.12k| c += 8; 1081| 1.12k| continue; 1082| 1.12k| } 1083| | 1084| 9.51k| const auto length = (countr_zero(next) >> 3); 1085| 9.51k| c += length; 1086| 9.51k| data += length; 1087| 9.51k| write_escape(); 1088| 9.51k| } 1089| 3.65k| } 1090| | 1091| | // Scalar tail 1092| 24.6k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 18.7k, False: 5.88k] ------------------ 1093| 18.7k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 4.10k, False: 14.6k] ------------------ 1094| 4.10k| std::memcpy(data, &escaped, 2); 1095| 4.10k| data += 2; 1096| 4.10k| } 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| 14.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| 14.6k| std::memcpy(data, c, 1); 1118| 14.6k| ++data; 1119| 14.6k| } 1120| 18.7k| } 1121| | 1122| 5.88k| ix += size_t(data - start); 1123| | 1124| 5.88k| std::memcpy(&b[ix], "\"", 1); 1125| 5.88k| ++ix; 1126| 5.88k| } 1127| 5.88k| } 1128| 5.88k| } 1129| 5.88k| } _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 5.88k| 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.88k| else { 953| 5.88k| return str_view(value); 954| 5.88k| } 955| 5.88k| }(); _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 19.7M| 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| 19.7M| 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| 19.7M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 19.7M| data += 2; 1044| 19.7M| } 1045| 19.7M| ++c; 1046| 19.7M| }; _ZZN3glz2toILj10ENSt3__17variantIJDnNS1_17basic_string_viewIcNS1_11char_traitsIcEEEElEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS5_NS1_9allocatorIcEEEERS7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clIRlEEDaSS_: 1965| 33.2k| [&](auto&& val) { 1966| 33.2k| using V = std::decay_t; 1967| | 1968| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| | custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| | if (missing_id(value, ctx)) { 1980| | return; 1981| | } 1982| | using id_type = std::decay_t[value.index()])>; 1983| | if constexpr (Opts.prettify) { 1984| | dump("{\n", b, ix); 1985| | ctx.depth += check_indentation_width(Opts); 1986| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| | dump('"', b, ix); 1988| | dump_maybe_empty(tag_v, b, ix); 1989| | if constexpr (std::integral) { 1990| | dump("\": ", b, ix); 1991| | serialize::op(ids_v[value.index()], ctx, b, ix); 1992| | } 1993| | else { 1994| | dump("\": \"", b, ix); 1995| | dump_maybe_empty(ids_v[value.index()], b, ix); 1996| | dump('"', b, ix); 1997| | } 1998| | const auto pos_after_tag = ix; 1999| | dump(",\n", b, ix); 2000| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| | const auto pos_body_start = ix; 2002| | to::template op()>(val, ctx, b, ix); 2003| | if (ix == pos_body_start) { 2004| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| | } 2006| | ctx.depth -= check_indentation_width(Opts); 2007| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| | return; 2009| | } 2010| | std::memcpy(&b[ix], "\n", 1); 2011| | ++ix; 2012| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| | ix += ctx.depth; 2014| | std::memcpy(&b[ix], "}", 1); 2015| | ++ix; 2016| | } 2017| | else { 2018| | dump("{\"", b, ix); 2019| | dump_maybe_empty(tag_v, b, ix); 2020| | if constexpr (std::integral) { 2021| | dump("\":", b, ix); 2022| | serialize::op(ids_v[value.index()], ctx, b, ix); 2023| | } 2024| | else { 2025| | dump("\":\"", b, ix); 2026| | dump_maybe_empty(ids_v[value.index()], b, ix); 2027| | dump('"', b, ix); 2028| | } 2029| | const auto pos_after_tag = ix; 2030| | dump(',', b, ix); 2031| | const auto pos_body_start = ix; 2032| | to::template op()>(val, ctx, b, ix); 2033| | if (ix == pos_body_start) { 2034| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| | } 2036| | dump('}', b, ix); 2037| | } 2038| | } 2039| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| | variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| | if (missing_id(value, ctx)) { 2044| | return; 2045| | } 2046| | if constexpr (Opts.prettify) { 2047| | dump("{\n", b, ix); 2048| | ctx.depth += check_indentation_width(Opts); 2049| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| | dump('"', b, ix); 2051| | dump_maybe_empty(tag_v, b, ix); 2052| | dump("\": ", b, ix); 2053| | write_id(value, ctx, b, ix); 2054| | ctx.depth -= check_indentation_width(Opts); 2055| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| | return; 2057| | } 2058| | std::memcpy(&b[ix], "\n", 1); 2059| | ++ix; 2060| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| | ix += ctx.depth; 2062| | std::memcpy(&b[ix], "}", 1); 2063| | ++ix; 2064| | } 2065| | else { 2066| | dump("{\"", b, ix); 2067| | dump_maybe_empty(tag_v, b, ix); 2068| | dump("\":", b, ix); 2069| | write_id(value, ctx, b, ix); 2070| | dump('}', b, ix); 2071| | } 2072| | } 2073| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| | (glaze_object_t || reflectable || is_memory_object) && 2075| | (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| | if (missing_id(value, ctx)) { 2081| | return; 2082| | } 2083| | constexpr auto N = []() { 2084| | if constexpr (is_memory_object) { 2085| | return reflect>::size; 2086| | } 2087| | else { 2088| | return reflect::size; 2089| | } 2090| | }(); 2091| | 2092| | // must first write out type 2093| | if constexpr (Opts.prettify) { 2094| | dump("{\n", b, ix); 2095| | ctx.depth += check_indentation_width(Opts); 2096| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| | dump('"', b, ix); 2098| | dump_maybe_empty(tag_v, b, ix); 2099| | 2100| | using id_type = std::decay_t[value.index()])>; 2101| | 2102| | if constexpr (std::integral) { 2103| | dump("\": ", b, ix); 2104| | serialize::op(ids_v[value.index()], ctx, b, ix); 2105| | if constexpr (N > 0) { 2106| | dump(",\n", b, ix); 2107| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| | } 2109| | } 2110| | else { 2111| | dump("\": \"", b, ix); 2112| | dump_maybe_empty(ids_v[value.index()], b, ix); 2113| | if constexpr (N == 0) { 2114| | dump('"', b, ix); 2115| | } 2116| | else { 2117| | dump("\",\n", b, ix); 2118| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| | } 2120| | } 2121| | } 2122| | else { 2123| | using id_type = std::decay_t[value.index()])>; 2124| | 2125| | dump("{\"", b, ix); 2126| | dump_maybe_empty(tag_v, b, ix); 2127| | 2128| | if constexpr (std::integral) { 2129| | dump("\":", b, ix); 2130| | serialize::op(ids_v[value.index()], ctx, b, ix); 2131| | if constexpr (N > 0) { 2132| | dump(',', b, ix); 2133| | } 2134| | } 2135| | else { 2136| | dump("\":\"", b, ix); 2137| | dump_maybe_empty(ids_v[value.index()], b, ix); 2138| | if constexpr (N == 0) { 2139| | dump('"', b, ix); 2140| | } 2141| | else { 2142| | dump("\",", b, ix); 2143| | } 2144| | } 2145| | } 2146| | if constexpr (is_memory_object) { 2147| | if (!val) [[unlikely]] { 2148| | ctx.error = error_code::invalid_variant_object; 2149| | return; 2150| | } 2151| | to>::template op()>(*val, ctx, b, ix); 2152| | } 2153| | else { 2154| | to::template op()>(val, ctx, b, ix); 2155| | } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| | if constexpr (Opts.skip_null_members) { 2158| | if (b[ix - 1] == ',') { 2159| | --ix; 2160| | } 2161| | } 2162| | 2163| | if constexpr (Opts.prettify) { 2164| | ctx.depth -= check_indentation_width(Opts); 2165| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| | return; 2167| | } 2168| | std::memcpy(&b[ix], "\n", 1); 2169| | ++ix; 2170| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| | ix += ctx.depth; 2172| | std::memcpy(&b[ix], "}", 1); 2173| | ++ix; 2174| | } 2175| | else { 2176| | dump('}', b, ix); 2177| | } 2178| | } 2179| 33.2k| else { 2180| 33.2k| to::template op(val, ctx, b, ix); 2181| 33.2k| } 2182| 33.2k| }, _ZN3glz2toILj10ElE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERlTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 33.2k| { 815| 33.2k| if constexpr (not check_write_unchecked(Opts)) { 816| 33.2k| static_assert(required_padding()); 817| 33.2k| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 33.2k] ------------------ 818| 0| return; 819| 0| } 820| 33.2k| } 821| | 822| 33.2k| 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| 33.2k| else { 832| 33.2k| write_chars::op(value, ctx, b, ix); 833| 33.2k| } 834| 33.2k| } _ZN3glz16required_paddingIlEEmv: 538| 33.2k| { 539| 33.2k| constexpr auto value = []() -> size_t { 540| 33.2k| if constexpr (boolean_like) { 541| 33.2k| return 8; 542| 33.2k| } 543| 33.2k| else if constexpr (num_t) { 544| 33.2k| if constexpr (std::floating_point) { 545| 33.2k| if constexpr (sizeof(T) > 8) { 546| 33.2k| return 64; 547| 33.2k| } 548| 33.2k| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 33.2k| return zmij::double_buffer_size + 4; 551| 33.2k| } 552| 33.2k| else { 553| 33.2k| return zmij::float_buffer_size + 4; 554| 33.2k| } 555| 33.2k| } 556| 33.2k| else if constexpr (sizeof(T) > 4) { 557| 33.2k| return 24; 558| 33.2k| } 559| 33.2k| else if constexpr (sizeof(T) > 2) { 560| 33.2k| return 16; 561| 33.2k| } 562| 33.2k| else { 563| 33.2k| return 8; 564| 33.2k| } 565| 33.2k| } 566| 33.2k| else if constexpr (nullable_like) { 567| 33.2k| if constexpr (has_value_type) { 568| 33.2k| return required_padding(); 569| 33.2k| } 570| 33.2k| else if constexpr (has_element_type) { 571| 33.2k| return required_padding(); 572| 33.2k| } 573| 33.2k| else { 574| 33.2k| return 0; 575| 33.2k| } 576| 33.2k| } 577| 33.2k| else if constexpr (always_null_t) { 578| 33.2k| return 8; 579| 33.2k| } 580| 33.2k| else { 581| 33.2k| return 0; 582| 33.2k| } 583| 33.2k| }(); 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| 33.2k| return value; 591| 33.2k| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 161| { 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| 161| 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| 161| else { 832| 161| write_chars::op(value, ctx, b, ix); 833| 161| } 834| 161| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 438| { 815| 438| if constexpr (not check_write_unchecked(Opts)) { 816| 438| static_assert(required_padding()); 817| 438| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 438] ------------------ 818| 0| return; 819| 0| } 820| 438| } 821| | 822| 438| 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| 438| else { 832| 438| write_chars::op(value, ctx, b, ix); 833| 438| } 834| 438| } _ZN3glz16required_paddingIiEEmv: 538| 733| { 539| 733| constexpr auto value = []() -> size_t { 540| 733| if constexpr (boolean_like) { 541| 733| return 8; 542| 733| } 543| 733| else if constexpr (num_t) { 544| 733| if constexpr (std::floating_point) { 545| 733| if constexpr (sizeof(T) > 8) { 546| 733| return 64; 547| 733| } 548| 733| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 733| return zmij::double_buffer_size + 4; 551| 733| } 552| 733| else { 553| 733| return zmij::float_buffer_size + 4; 554| 733| } 555| 733| } 556| 733| else if constexpr (sizeof(T) > 4) { 557| 733| return 24; 558| 733| } 559| 733| else if constexpr (sizeof(T) > 2) { 560| 733| return 16; 561| 733| } 562| 733| else { 563| 733| return 8; 564| 733| } 565| 733| } 566| 733| else if constexpr (nullable_like) { 567| 733| if constexpr (has_value_type) { 568| 733| return required_padding(); 569| 733| } 570| 733| else if constexpr (has_element_type) { 571| 733| return required_padding(); 572| 733| } 573| 733| else { 574| 733| return 0; 575| 733| } 576| 733| } 577| 733| else if constexpr (always_null_t) { 578| 733| return 8; 579| 733| } 580| 733| else { 581| 733| return 0; 582| 733| } 583| 733| }(); 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| 733| return value; 591| 733| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 295| { 815| 295| if constexpr (not check_write_unchecked(Opts)) { 816| 295| static_assert(required_padding()); 817| 295| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 295] ------------------ 818| 0| return; 819| 0| } 820| 295| } 821| | 822| 295| 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| 295| else { 832| 295| write_chars::op(value, ctx, b, ix); 833| 295| } 834| 295| } _ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2471| 129| { 2472| 129| using ValueType = std::decay_t; 2473| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2474| | constexpr auto& writer = meta_unknown_write_v; 2475| | 2476| | using WriterType = meta_unknown_write_t; 2477| | if constexpr (std::is_member_object_pointer_v) { 2478| | decltype(auto) unknown_writer = value.*writer; 2479| | if (unknown_writer.size() > 0) { 2480| | // TODO: This intermediate is added to get GCC 14 to build 2481| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2482| | serialize::op()>(std::move(merged), ctx, b, ix); 2483| | } 2484| | else { 2485| | serialize::op()>(value, ctx, b, ix); 2486| | } 2487| | } 2488| | else if constexpr (std::is_member_function_pointer_v) { 2489| | decltype(auto) unknown_writer = (value.*writer)(); 2490| | if (unknown_writer.size() > 0) { 2491| | // TODO: This intermediate is added to get GCC 14 to build 2492| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2493| | serialize::op()>(std::move(merged), ctx, b, ix); 2494| | } 2495| | else { 2496| | serialize::op()>(value, ctx, b, ix); 2497| | } 2498| | } 2499| | else { 2500| | static_assert(false_v, "unknown_write type not handled"); 2501| | } 2502| | } 2503| 129| else { 2504| | // handles glaze_object_t without extra unknown fields 2505| 129| static constexpr auto Opts = 2506| 129| disable_write_unknown_off()>()>(); 2507| | 2508| 129| if constexpr (not check_opening_handled(Options)) { 2509| | if constexpr (Options.prettify) { 2510| | ctx.depth += check_indentation_width(Options); 2511| | if constexpr (not check_write_unchecked(Options)) { 2512| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2513| | return; 2514| | } 2515| | } 2516| | std::memcpy(&b[ix], "{\n", 2); 2517| | ix += 2; 2518| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2519| | ix += ctx.depth; 2520| | } 2521| 129| else { 2522| 129| if constexpr (not check_write_unchecked(Options)) { 2523| 129| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2523:26): [True: 0, False: 129] ------------------ 2524| 0| return; 2525| 0| } 2526| 129| } 2527| 129| dump('{', b, ix); 2528| 129| } 2529| 129| } 2530| | 2531| 0| static constexpr auto N = reflect::size; 2532| | 2533| 129| decltype(auto) t = [&]() -> decltype(auto) { 2534| 129| if constexpr (reflectable) { 2535| 129| return to_tie(value); 2536| 129| } 2537| 129| else { 2538| 129| return nullptr; 2539| 129| } 2540| 129| }(); 2541| | 2542| 129| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2543| | if constexpr (maybe_skipped) { 2544| | bool first = true; 2545| | for_each([&]() { 2546| | using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| | else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| | if (is_glaze_value_field_null(value, t)) return; 2601| | } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| | else { 2621| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2622| | return; 2623| | } 2624| | } 2625| | 2626| | if (first) { 2627| | first = false; 2628| | } 2629| | else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| | else { 2638| | std::memcpy(&b[ix], ",", 1); 2639| | ++ix; 2640| | } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| | } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| | static constexpr auto quoted_key = quoted_key_v; 2649| | static constexpr auto n = quoted_key.size(); 2650| | std::memcpy(&b[ix], quoted_key.data(), n); 2651| | ix += n; 2652| | 2653| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2654| | if constexpr (reflectable) { 2655| | to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| | } 2662| | }); 2663| | } 2664| 129| else { 2665| 129| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2665:57): [Folded, False: 129] ------------------ 2666| 129| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2667| 129| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2667:23): [True: 0, False: 129] ------------------ 2668| 0| return; 2669| 0| } 2670| 129| } 2671| | 2672| 129| for_each([&]() { 2673| 129| if constexpr (write_can_error()) { 2674| 129| if (bool(ctx.error)) [[unlikely]] { 2675| 129| return; 2676| 129| } 2677| 129| } 2678| 129| if constexpr (not fixed_max_size) { 2679| 129| if constexpr (Opts.prettify) { 2680| 129| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| 129| return; 2682| 129| } 2683| 129| } 2684| 129| else { 2685| 129| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| 129| return; 2687| 129| } 2688| 129| } 2689| 129| } 2690| | 2691| 129| if constexpr (I != 0 && Opts.prettify) { 2692| 129| std::memcpy(&b[ix], ",\n", 2); 2693| 129| ix += 2; 2694| 129| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| 129| ix += ctx.depth; 2696| 129| } 2697| | 2698| 129| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 129| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| 129| if constexpr (always_null_t) { 2703| 129| if constexpr (I == 0 || Opts.prettify) { 2704| 129| static constexpr auto quoted_key = join_v, chars<"null">>; 2705| 129| static constexpr auto n = quoted_key.size(); 2706| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2707| 129| ix += n; 2708| 129| } 2709| 129| else { 2710| 129| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| 129| static constexpr auto n = quoted_key.size(); 2712| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2713| 129| ix += n; 2714| 129| } 2715| 129| } 2716| 129| else { 2717| 129| if constexpr (I == 0 || Opts.prettify) { 2718| 129| static constexpr auto quoted_key = quoted_key_v; 2719| 129| static constexpr auto n = quoted_key.size(); 2720| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 129| ix += n; 2722| 129| } 2723| 129| else { 2724| 129| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 129| static constexpr auto n = quoted_key.size(); 2726| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 129| ix += n; 2728| 129| } 2729| | 2730| 129| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2731| 129| if constexpr (reflectable) { 2732| 129| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| 129| } 2734| 129| else { 2735| 129| to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| 129| ix); 2737| 129| } 2738| 129| } 2739| 129| }); 2740| 129| } 2741| | 2742| | // Options is required here, because it must be the top level 2743| 129| if constexpr (not check_closing_handled(Options)) { 2744| | if constexpr (Options.prettify) { 2745| | ctx.depth -= check_indentation_width(Options); 2746| | if constexpr (not check_write_unchecked(Options)) { 2747| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2748| | return; 2749| | } 2750| | } 2751| | std::memcpy(&b[ix], "\n", 1); 2752| | ++ix; 2753| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2754| | ix += ctx.depth; 2755| | std::memcpy(&b[ix], "}", 1); 2756| | ++ix; 2757| | } 2758| 129| else { 2759| 129| dump || check_write_unchecked(Options))>('}', b, ix); 2760| 129| } 2761| 129| } 2762| 129| } 2763| 129| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2533| 129| decltype(auto) t = [&]() -> decltype(auto) { 2534| 129| if constexpr (reflectable) { 2535| 129| return to_tie(value); 2536| | } 2537| | else { 2538| | return nullptr; 2539| | } 2540| 129| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2672| 129| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| | if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| | else { 2685| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| | return; 2687| | } 2688| | } 2689| | } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 129| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 129| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 129| else { 2717| 129| if constexpr (I == 0 || Opts.prettify) { 2718| 129| static constexpr auto quoted_key = quoted_key_v; 2719| 129| static constexpr auto n = quoted_key.size(); 2720| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 129| ix += n; 2722| | } 2723| | else { 2724| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| | static constexpr auto n = quoted_key.size(); 2726| | std::memcpy(&b[ix], quoted_key.data(), n); 2727| | ix += n; 2728| | } 2729| | 2730| 129| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [True: 0, Folded] ------------------ 2731| 129| if constexpr (reflectable) { 2732| 129| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 129| } 2739| 129| }); _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 896| { 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| 896| 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| 896| else { 832| 896| write_chars::op(value, ctx, b, ix); 833| 896| } 834| 896| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2672| 129| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| | if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| | else { 2685| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| | return; 2687| | } 2688| | } 2689| | } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 129| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 129| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 129| else { 2717| | if constexpr (I == 0 || Opts.prettify) { 2718| | static constexpr auto quoted_key = quoted_key_v; 2719| | static constexpr auto n = quoted_key.size(); 2720| | std::memcpy(&b[ix], quoted_key.data(), n); 2721| | ix += n; 2722| | } 2723| 129| else { 2724| 129| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 129| static constexpr auto n = quoted_key.size(); 2726| 129| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 129| ix += n; 2728| 129| } 2729| | 2730| 129| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [True: 0, Folded] ------------------ 2731| 129| if constexpr (reflectable) { 2732| 129| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 129| } 2739| 129| }); _ZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2471| 60| { 2472| 60| using ValueType = std::decay_t; 2473| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2474| | constexpr auto& writer = meta_unknown_write_v; 2475| | 2476| | using WriterType = meta_unknown_write_t; 2477| | if constexpr (std::is_member_object_pointer_v) { 2478| | decltype(auto) unknown_writer = value.*writer; 2479| | if (unknown_writer.size() > 0) { 2480| | // TODO: This intermediate is added to get GCC 14 to build 2481| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2482| | serialize::op()>(std::move(merged), ctx, b, ix); 2483| | } 2484| | else { 2485| | serialize::op()>(value, ctx, b, ix); 2486| | } 2487| | } 2488| | else if constexpr (std::is_member_function_pointer_v) { 2489| | decltype(auto) unknown_writer = (value.*writer)(); 2490| | if (unknown_writer.size() > 0) { 2491| | // TODO: This intermediate is added to get GCC 14 to build 2492| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2493| | serialize::op()>(std::move(merged), ctx, b, ix); 2494| | } 2495| | else { 2496| | serialize::op()>(value, ctx, b, ix); 2497| | } 2498| | } 2499| | else { 2500| | static_assert(false_v, "unknown_write type not handled"); 2501| | } 2502| | } 2503| 60| else { 2504| | // handles glaze_object_t without extra unknown fields 2505| 60| static constexpr auto Opts = 2506| 60| disable_write_unknown_off()>()>(); 2507| | 2508| 60| if constexpr (not check_opening_handled(Options)) { 2509| | if constexpr (Options.prettify) { 2510| | ctx.depth += check_indentation_width(Options); 2511| | if constexpr (not check_write_unchecked(Options)) { 2512| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2513| | return; 2514| | } 2515| | } 2516| | std::memcpy(&b[ix], "{\n", 2); 2517| | ix += 2; 2518| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2519| | ix += ctx.depth; 2520| | } 2521| 60| else { 2522| 60| if constexpr (not check_write_unchecked(Options)) { 2523| 60| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2523:26): [True: 0, False: 60] ------------------ 2524| 0| return; 2525| 0| } 2526| 60| } 2527| 60| dump('{', b, ix); 2528| 60| } 2529| 60| } 2530| | 2531| 0| static constexpr auto N = reflect::size; 2532| | 2533| 60| decltype(auto) t = [&]() -> decltype(auto) { 2534| 60| if constexpr (reflectable) { 2535| 60| return to_tie(value); 2536| 60| } 2537| 60| else { 2538| 60| return nullptr; 2539| 60| } 2540| 60| }(); 2541| | 2542| 60| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2543| 60| if constexpr (maybe_skipped) { 2544| 60| bool first = true; 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| 60| if constexpr (skipped_on_write) { 2551| 60| return; 2552| 60| } 2553| 60| else { 2554| 60| if constexpr (meta_has_skip_if) { 2555| 60| static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| 60| static constexpr meta_context mctx{.op = operation::serialize}; 2557| 60| decltype(auto) field_value = [&]() -> decltype(auto) { 2558| 60| if constexpr (reflectable) { 2559| 60| return get(t); 2560| 60| } 2561| 60| else { 2562| 60| return get_member(value, glz::get(reflect::values)); 2563| 60| } 2564| 60| }(); 2565| 60| if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| 60| } 2567| | 2568| 60| if constexpr (null_t && Opts.skip_null_members) { 2569| 60| if constexpr (always_null_t) 2570| 60| return; 2571| 60| else { 2572| 60| const auto is_null = [&]() { 2573| 60| decltype(auto) element = [&]() -> decltype(auto) { 2574| 60| if constexpr (reflectable) { 2575| 60| return get(t); 2576| 60| } 2577| 60| else { 2578| 60| return get(reflect::values); 2579| 60| } 2580| 60| }; 2581| | 2582| 60| if constexpr (nullable_wrapper) { 2583| 60| return !bool(element()(value).val); 2584| 60| } 2585| 60| else if constexpr (nullable_value_t) { 2586| 60| return !get_member(value, element()).has_value(); 2587| 60| } 2588| 60| else { 2589| 60| return !bool(get_member(value, element())); 2590| 60| } 2591| 60| }(); 2592| 60| if (is_null) return; 2593| 60| } 2594| 60| } 2595| 60| else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| 60| custom_getter_returns_nullable()) { 2597| 60| if (is_custom_field_null(value, t, ctx)) return; 2598| 60| } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| 60| if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| 60| decltype(auto) member = [&]() -> decltype(auto) { 2605| 60| if constexpr (reflectable) { 2606| 60| return get_member(value, get(t)); 2607| 60| } 2608| 60| else { 2609| 60| return get_member(value, get(reflect::values)); 2610| 60| } 2611| 60| }(); 2612| 60| if (is_default_value(member)) return; 2613| 60| } 2614| | 2615| 60| if constexpr (Opts.prettify) { 2616| 60| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| 60| return; 2618| 60| } 2619| 60| } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2622| 60| return; 2623| 60| } 2624| 60| } 2625| | 2626| 60| if (first) { 2627| 60| first = false; 2628| 60| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| 60| if constexpr (Opts.prettify) { 2632| 60| std::memcpy(&b[ix], ",\n", 2); 2633| 60| ix += 2; 2634| 60| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| 60| ix += ctx.depth; 2636| 60| } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| 60| if constexpr (is_output_streaming) { 2642| 60| flush_buffer(b, ix); 2643| 60| } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| 60| } 2657| 60| else { 2658| 60| to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| 60| ix); 2660| 60| } 2661| 60| } 2662| 60| }); 2663| | } 2664| | else { 2665| | static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; 2666| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2667| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2668| | return; 2669| | } 2670| | } 2671| | 2672| | for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| | if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| | else { 2685| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| | return; 2687| | } 2688| | } 2689| | } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| | using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| | else { 2717| | if constexpr (I == 0 || Opts.prettify) { 2718| | static constexpr auto quoted_key = quoted_key_v; 2719| | static constexpr auto n = quoted_key.size(); 2720| | std::memcpy(&b[ix], quoted_key.data(), n); 2721| | ix += n; 2722| | } 2723| | else { 2724| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| | static constexpr auto n = quoted_key.size(); 2726| | std::memcpy(&b[ix], quoted_key.data(), n); 2727| | ix += n; 2728| | } 2729| | 2730| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2731| | if constexpr (reflectable) { 2732| | to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| | } 2739| | }); 2740| | } 2741| | 2742| | // Options is required here, because it must be the top level 2743| 60| if constexpr (not check_closing_handled(Options)) { 2744| | if constexpr (Options.prettify) { 2745| | ctx.depth -= check_indentation_width(Options); 2746| | if constexpr (not check_write_unchecked(Options)) { 2747| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2748| | return; 2749| | } 2750| | } 2751| | std::memcpy(&b[ix], "\n", 1); 2752| | ++ix; 2753| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2754| | ix += ctx.depth; 2755| | std::memcpy(&b[ix], "}", 1); 2756| | ++ix; 2757| | } 2758| 60| else { 2759| 60| dump || check_write_unchecked(Options))>('}', b, ix); 2760| 60| } 2761| 60| } 2762| 60| } 2763| 60| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2533| 60| decltype(auto) t = [&]() -> decltype(auto) { 2534| 60| if constexpr (reflectable) { 2535| 60| return to_tie(value); 2536| | } 2537| | else { 2538| | return nullptr; 2539| | } 2540| 60| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 60, False: 0] ------------------ 2627| 60| first = false; 2628| 60| } 2629| 0| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 0| else { 2638| 0| std::memcpy(&b[ix], ",", 1); 2639| 0| ++ix; 2640| 0| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 0| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [True: 0, Folded] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 1.02k| { 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| 1.02k| 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| 1.02k| else { 945| 1.02k| const sv str = [&]() -> const sv { 946| 1.02k| if constexpr (array_char_t) { 947| 1.02k| return sv{value.data(), value.size()}; 948| 1.02k| } 949| 1.02k| else if constexpr (u8str_t) { 950| 1.02k| return sv{reinterpret_cast(value.data()), value.size()}; 951| 1.02k| } 952| 1.02k| else { 953| 1.02k| return str_view(value); 954| 1.02k| } 955| 1.02k| }(); 956| 1.02k| 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| 1.02k| else { 988| | // Using the original sizing 989| 1.02k| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 1.02k] ------------------ 990| 0| return; 991| 0| } 992| 1.02k| } 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| 1.02k| else { 1002| 1.02k| std::memcpy(&b[ix], "\"", 1); 1003| 1.02k| ++ix; 1004| | 1005| 1.02k| const auto* c = str.data(); 1006| 1.02k| const auto* const e = c + n; 1007| 1.02k| const auto start = &b[ix]; 1008| 1.02k| 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| 1.02k| auto write_escape = [&]() { 1017| 1.02k| if constexpr (check_escape_control_characters(Opts)) { 1018| 1.02k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 1.02k| std::memcpy(data, &escaped, 2); 1020| 1.02k| data += 2; 1021| 1.02k| } 1022| 1.02k| else { 1023| 1.02k| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 1.02k| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 1.02k| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 1.02k| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 1.02k| std::memcpy(data, unicode_escape, 6); 1028| 1.02k| data += 6; 1029| 1.02k| } 1030| 1.02k| } 1031| 1.02k| else { 1032| 1.02k| 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| 1.02k| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 1.02k| ctx.error = error_code::invalid_control_character; 1040| 1.02k| } 1041| 1.02k| } 1042| 1.02k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 1.02k| data += 2; 1044| 1.02k| } 1045| 1.02k| ++c; 1046| 1.02k| }; 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| 1.02k|#if defined(GLZ_USE_SSE2) 1055| 1.02k| 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| 1.02k| if (n > 7) { ------------------ | Branch (1061:23): [True: 386, False: 637] ------------------ 1062| 859| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 473, False: 386] ------------------ 1063| 473| std::memcpy(data, c, 8); 1064| 473| uint64_t swar; 1065| 473| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 473| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 473| const uint64_t lo7 = swar & lo7_mask; 1072| 473| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 473| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 473| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 473| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 473| next &= repeat_byte8(0b10000000); 1078| 473| if (next == 0) { ------------------ | Branch (1078:29): [True: 194, False: 279] ------------------ 1079| 194| data += 8; 1080| 194| c += 8; 1081| 194| continue; 1082| 194| } 1083| | 1084| 279| const auto length = (countr_zero(next) >> 3); 1085| 279| c += length; 1086| 279| data += length; 1087| 279| write_escape(); 1088| 279| } 1089| 386| } 1090| | 1091| | // Scalar tail 1092| 3.67k| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 2.65k, False: 1.02k] ------------------ 1093| 2.65k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 340, False: 2.31k] ------------------ 1094| 340| std::memcpy(data, &escaped, 2); 1095| 340| data += 2; 1096| 340| } 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.31k| 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.31k| std::memcpy(data, c, 1); 1118| 2.31k| ++data; 1119| 2.31k| } 1120| 2.65k| } 1121| | 1122| 1.02k| ix += size_t(data - start); 1123| | 1124| 1.02k| std::memcpy(&b[ix], "\"", 1); 1125| 1.02k| ++ix; 1126| 1.02k| } 1127| 1.02k| } 1128| 1.02k| } 1129| 1.02k| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 1.02k| 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| 1.02k| else { 953| 1.02k| return str_view(value); 954| 1.02k| } 955| 1.02k| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 7.24k| 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| 7.24k| 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| 7.24k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 7.24k| data += 2; 1044| 7.24k| } 1045| 7.24k| ++c; 1046| 7.24k| }; _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm2EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2471| 319| { 2472| 319| using ValueType = std::decay_t; 2473| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2474| | constexpr auto& writer = meta_unknown_write_v; 2475| | 2476| | using WriterType = meta_unknown_write_t; 2477| | if constexpr (std::is_member_object_pointer_v) { 2478| | decltype(auto) unknown_writer = value.*writer; 2479| | if (unknown_writer.size() > 0) { 2480| | // TODO: This intermediate is added to get GCC 14 to build 2481| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2482| | serialize::op()>(std::move(merged), ctx, b, ix); 2483| | } 2484| | else { 2485| | serialize::op()>(value, ctx, b, ix); 2486| | } 2487| | } 2488| | else if constexpr (std::is_member_function_pointer_v) { 2489| | decltype(auto) unknown_writer = (value.*writer)(); 2490| | if (unknown_writer.size() > 0) { 2491| | // TODO: This intermediate is added to get GCC 14 to build 2492| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2493| | serialize::op()>(std::move(merged), ctx, b, ix); 2494| | } 2495| | else { 2496| | serialize::op()>(value, ctx, b, ix); 2497| | } 2498| | } 2499| | else { 2500| | static_assert(false_v, "unknown_write type not handled"); 2501| | } 2502| | } 2503| 319| else { 2504| | // handles glaze_object_t without extra unknown fields 2505| 319| static constexpr auto Opts = 2506| 319| disable_write_unknown_off()>()>(); 2507| | 2508| 319| if constexpr (not check_opening_handled(Options)) { 2509| | if constexpr (Options.prettify) { 2510| | ctx.depth += check_indentation_width(Options); 2511| | if constexpr (not check_write_unchecked(Options)) { 2512| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2513| | return; 2514| | } 2515| | } 2516| | std::memcpy(&b[ix], "{\n", 2); 2517| | ix += 2; 2518| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2519| | ix += ctx.depth; 2520| | } 2521| 319| else { 2522| 319| if constexpr (not check_write_unchecked(Options)) { 2523| 319| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2523:26): [True: 0, False: 319] ------------------ 2524| 0| return; 2525| 0| } 2526| 319| } 2527| 319| dump('{', b, ix); 2528| 319| } 2529| 319| } 2530| | 2531| 0| static constexpr auto N = reflect::size; 2532| | 2533| 319| decltype(auto) t = [&]() -> decltype(auto) { 2534| 319| if constexpr (reflectable) { 2535| 319| return to_tie(value); 2536| 319| } 2537| 319| else { 2538| 319| return nullptr; 2539| 319| } 2540| 319| }(); 2541| | 2542| 319| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2543| | if constexpr (maybe_skipped) { 2544| | bool first = true; 2545| | for_each([&]() { 2546| | using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| | else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| | if (is_glaze_value_field_null(value, t)) return; 2601| | } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| | else { 2621| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2622| | return; 2623| | } 2624| | } 2625| | 2626| | if (first) { 2627| | first = false; 2628| | } 2629| | else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| | else { 2638| | std::memcpy(&b[ix], ",", 1); 2639| | ++ix; 2640| | } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| | } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| | static constexpr auto quoted_key = quoted_key_v; 2649| | static constexpr auto n = quoted_key.size(); 2650| | std::memcpy(&b[ix], quoted_key.data(), n); 2651| | ix += n; 2652| | 2653| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2654| | if constexpr (reflectable) { 2655| | to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| | } 2662| | }); 2663| | } 2664| 319| else { 2665| 319| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2665:57): [Folded, False: 319] ------------------ 2666| 319| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2667| 319| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2667:23): [True: 0, False: 319] ------------------ 2668| 0| return; 2669| 0| } 2670| 319| } 2671| | 2672| 319| for_each([&]() { 2673| 319| if constexpr (write_can_error()) { 2674| 319| if (bool(ctx.error)) [[unlikely]] { 2675| 319| return; 2676| 319| } 2677| 319| } 2678| 319| if constexpr (not fixed_max_size) { 2679| 319| if constexpr (Opts.prettify) { 2680| 319| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| 319| return; 2682| 319| } 2683| 319| } 2684| 319| else { 2685| 319| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| 319| return; 2687| 319| } 2688| 319| } 2689| 319| } 2690| | 2691| 319| if constexpr (I != 0 && Opts.prettify) { 2692| 319| std::memcpy(&b[ix], ",\n", 2); 2693| 319| ix += 2; 2694| 319| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| 319| ix += ctx.depth; 2696| 319| } 2697| | 2698| 319| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 319| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| 319| if constexpr (always_null_t) { 2703| 319| if constexpr (I == 0 || Opts.prettify) { 2704| 319| static constexpr auto quoted_key = join_v, chars<"null">>; 2705| 319| static constexpr auto n = quoted_key.size(); 2706| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2707| 319| ix += n; 2708| 319| } 2709| 319| else { 2710| 319| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| 319| static constexpr auto n = quoted_key.size(); 2712| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2713| 319| ix += n; 2714| 319| } 2715| 319| } 2716| 319| else { 2717| 319| if constexpr (I == 0 || Opts.prettify) { 2718| 319| static constexpr auto quoted_key = quoted_key_v; 2719| 319| static constexpr auto n = quoted_key.size(); 2720| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 319| ix += n; 2722| 319| } 2723| 319| else { 2724| 319| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 319| static constexpr auto n = quoted_key.size(); 2726| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 319| ix += n; 2728| 319| } 2729| | 2730| 319| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2731| 319| if constexpr (reflectable) { 2732| 319| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| 319| } 2734| 319| else { 2735| 319| to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| 319| ix); 2737| 319| } 2738| 319| } 2739| 319| }); 2740| 319| } 2741| | 2742| | // Options is required here, because it must be the top level 2743| 319| if constexpr (not check_closing_handled(Options)) { 2744| | if constexpr (Options.prettify) { 2745| | ctx.depth -= check_indentation_width(Options); 2746| | if constexpr (not check_write_unchecked(Options)) { 2747| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2748| | return; 2749| | } 2750| | } 2751| | std::memcpy(&b[ix], "\n", 1); 2752| | ++ix; 2753| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2754| | ix += ctx.depth; 2755| | std::memcpy(&b[ix], "}", 1); 2756| | ++ix; 2757| | } 2758| 319| else { 2759| 319| dump || check_write_unchecked(Options))>('}', b, ix); 2760| 319| } 2761| 319| } 2762| 319| } 2763| 319| } _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2533| 319| decltype(auto) t = [&]() -> decltype(auto) { 2534| 319| if constexpr (reflectable) { 2535| 319| return to_tie(value); 2536| | } 2537| | else { 2538| | return nullptr; 2539| | } 2540| 319| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2672| 319| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| | if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| | else { 2685| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| | return; 2687| | } 2688| | } 2689| | } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 319| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 319| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 319| else { 2717| 319| if constexpr (I == 0 || Opts.prettify) { 2718| 319| static constexpr auto quoted_key = quoted_key_v; 2719| 319| static constexpr auto n = quoted_key.size(); 2720| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 319| ix += n; 2722| | } 2723| | else { 2724| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| | static constexpr auto n = quoted_key.size(); 2726| | std::memcpy(&b[ix], quoted_key.data(), n); 2727| | ix += n; 2728| | } 2729| | 2730| 319| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [True: 0, Folded] ------------------ 2731| 319| if constexpr (reflectable) { 2732| 319| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 319| } 2739| 319| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2672| 319| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| | if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| | else { 2685| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| | return; 2687| | } 2688| | } 2689| | } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 319| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 319| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 319| else { 2717| | if constexpr (I == 0 || Opts.prettify) { 2718| | static constexpr auto quoted_key = quoted_key_v; 2719| | static constexpr auto n = quoted_key.size(); 2720| | std::memcpy(&b[ix], quoted_key.data(), n); 2721| | ix += n; 2722| | } 2723| 319| else { 2724| 319| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 319| static constexpr auto n = quoted_key.size(); 2726| 319| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 319| ix += n; 2728| 319| } 2729| | 2730| 319| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [True: 0, Folded] ------------------ 2731| 319| if constexpr (reflectable) { 2732| 319| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 319| } 2739| 319| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm3EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2471| 101| { 2472| 101| using ValueType = std::decay_t; 2473| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2474| | constexpr auto& writer = meta_unknown_write_v; 2475| | 2476| | using WriterType = meta_unknown_write_t; 2477| | if constexpr (std::is_member_object_pointer_v) { 2478| | decltype(auto) unknown_writer = value.*writer; 2479| | if (unknown_writer.size() > 0) { 2480| | // TODO: This intermediate is added to get GCC 14 to build 2481| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2482| | serialize::op()>(std::move(merged), ctx, b, ix); 2483| | } 2484| | else { 2485| | serialize::op()>(value, ctx, b, ix); 2486| | } 2487| | } 2488| | else if constexpr (std::is_member_function_pointer_v) { 2489| | decltype(auto) unknown_writer = (value.*writer)(); 2490| | if (unknown_writer.size() > 0) { 2491| | // TODO: This intermediate is added to get GCC 14 to build 2492| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2493| | serialize::op()>(std::move(merged), ctx, b, ix); 2494| | } 2495| | else { 2496| | serialize::op()>(value, ctx, b, ix); 2497| | } 2498| | } 2499| | else { 2500| | static_assert(false_v, "unknown_write type not handled"); 2501| | } 2502| | } 2503| 101| else { 2504| | // handles glaze_object_t without extra unknown fields 2505| 101| static constexpr auto Opts = 2506| 101| disable_write_unknown_off()>()>(); 2507| | 2508| 101| if constexpr (not check_opening_handled(Options)) { 2509| | if constexpr (Options.prettify) { 2510| | ctx.depth += check_indentation_width(Options); 2511| | if constexpr (not check_write_unchecked(Options)) { 2512| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2513| | return; 2514| | } 2515| | } 2516| | std::memcpy(&b[ix], "{\n", 2); 2517| | ix += 2; 2518| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2519| | ix += ctx.depth; 2520| | } 2521| 101| else { 2522| 101| if constexpr (not check_write_unchecked(Options)) { 2523| 101| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2523:26): [True: 0, False: 101] ------------------ 2524| 0| return; 2525| 0| } 2526| 101| } 2527| 101| dump('{', b, ix); 2528| 101| } 2529| 101| } 2530| | 2531| 0| static constexpr auto N = reflect::size; 2532| | 2533| 101| decltype(auto) t = [&]() -> decltype(auto) { 2534| 101| if constexpr (reflectable) { 2535| 101| return to_tie(value); 2536| 101| } 2537| 101| else { 2538| 101| return nullptr; 2539| 101| } 2540| 101| }(); 2541| | 2542| 101| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2543| | if constexpr (maybe_skipped) { 2544| | bool first = true; 2545| | for_each([&]() { 2546| | using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| | else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| | if (is_glaze_value_field_null(value, t)) return; 2601| | } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| | else { 2621| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2622| | return; 2623| | } 2624| | } 2625| | 2626| | if (first) { 2627| | first = false; 2628| | } 2629| | else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| | else { 2638| | std::memcpy(&b[ix], ",", 1); 2639| | ++ix; 2640| | } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| | } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| | static constexpr auto quoted_key = quoted_key_v; 2649| | static constexpr auto n = quoted_key.size(); 2650| | std::memcpy(&b[ix], quoted_key.data(), n); 2651| | ix += n; 2652| | 2653| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2654| | if constexpr (reflectable) { 2655| | to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| | } 2662| | }); 2663| | } 2664| 101| else { 2665| 101| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2665:57): [Folded, False: 101] ------------------ 2666| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2667| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2668| | return; 2669| | } 2670| | } 2671| | 2672| 101| for_each([&]() { 2673| 101| if constexpr (write_can_error()) { 2674| 101| if (bool(ctx.error)) [[unlikely]] { 2675| 101| return; 2676| 101| } 2677| 101| } 2678| 101| if constexpr (not fixed_max_size) { 2679| 101| if constexpr (Opts.prettify) { 2680| 101| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| 101| return; 2682| 101| } 2683| 101| } 2684| 101| else { 2685| 101| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2686| 101| return; 2687| 101| } 2688| 101| } 2689| 101| } 2690| | 2691| 101| if constexpr (I != 0 && Opts.prettify) { 2692| 101| std::memcpy(&b[ix], ",\n", 2); 2693| 101| ix += 2; 2694| 101| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| 101| ix += ctx.depth; 2696| 101| } 2697| | 2698| 101| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 101| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| 101| if constexpr (always_null_t) { 2703| 101| if constexpr (I == 0 || Opts.prettify) { 2704| 101| static constexpr auto quoted_key = join_v, chars<"null">>; 2705| 101| static constexpr auto n = quoted_key.size(); 2706| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2707| 101| ix += n; 2708| 101| } 2709| 101| else { 2710| 101| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| 101| static constexpr auto n = quoted_key.size(); 2712| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2713| 101| ix += n; 2714| 101| } 2715| 101| } 2716| 101| else { 2717| 101| if constexpr (I == 0 || Opts.prettify) { 2718| 101| static constexpr auto quoted_key = quoted_key_v; 2719| 101| static constexpr auto n = quoted_key.size(); 2720| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 101| ix += n; 2722| 101| } 2723| 101| else { 2724| 101| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 101| static constexpr auto n = quoted_key.size(); 2726| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 101| ix += n; 2728| 101| } 2729| | 2730| 101| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2731| 101| if constexpr (reflectable) { 2732| 101| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| 101| } 2734| 101| else { 2735| 101| to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| 101| ix); 2737| 101| } 2738| 101| } 2739| 101| }); 2740| 101| } 2741| | 2742| | // Options is required here, because it must be the top level 2743| 101| if constexpr (not check_closing_handled(Options)) { 2744| | if constexpr (Options.prettify) { 2745| | ctx.depth -= check_indentation_width(Options); 2746| | if constexpr (not check_write_unchecked(Options)) { 2747| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2748| | return; 2749| | } 2750| | } 2751| | std::memcpy(&b[ix], "\n", 1); 2752| | ++ix; 2753| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2754| | ix += ctx.depth; 2755| | std::memcpy(&b[ix], "}", 1); 2756| | ++ix; 2757| | } 2758| 101| else { 2759| 101| dump || check_write_unchecked(Options))>('}', b, ix); 2760| 101| } 2761| 101| } 2762| 101| } 2763| 101| } _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2533| 101| decltype(auto) t = [&]() -> decltype(auto) { 2534| 101| if constexpr (reflectable) { 2535| 101| return to_tie(value); 2536| | } 2537| | else { 2538| | return nullptr; 2539| | } 2540| 101| }(); _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2672| 101| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| 101| if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| 101| else { 2685| 101| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2685:29): [True: 0, False: 101] ------------------ 2686| 0| return; 2687| 0| } 2688| 101| } 2689| 101| } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 101| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 101| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 101| else { 2717| 101| if constexpr (I == 0 || Opts.prettify) { 2718| 101| static constexpr auto quoted_key = quoted_key_v; 2719| 101| static constexpr auto n = quoted_key.size(); 2720| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2721| 101| ix += n; 2722| | } 2723| | else { 2724| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| | static constexpr auto n = quoted_key.size(); 2726| | std::memcpy(&b[ix], quoted_key.data(), n); 2727| | ix += n; 2728| | } 2729| | 2730| 101| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [True: 0, Folded] ------------------ 2731| 101| if constexpr (reflectable) { 2732| 101| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 101| } 2739| 101| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2672| 101| for_each([&]() { 2673| | if constexpr (write_can_error()) { 2674| | if (bool(ctx.error)) [[unlikely]] { 2675| | return; 2676| | } 2677| | } 2678| 101| if constexpr (not fixed_max_size) { 2679| | if constexpr (Opts.prettify) { 2680| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2681| | return; 2682| | } 2683| | } 2684| 101| else { 2685| 101| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2685:29): [True: 0, False: 101] ------------------ 2686| 0| return; 2687| 0| } 2688| 101| } 2689| 101| } 2690| | 2691| | if constexpr (I != 0 && Opts.prettify) { 2692| | std::memcpy(&b[ix], ",\n", 2); 2693| | ix += 2; 2694| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2695| | ix += ctx.depth; 2696| | } 2697| | 2698| 101| using val_t = field_t; 2699| | 2700| | // MSVC requires get rather than keys[I] 2701| 101| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2702| | if constexpr (always_null_t) { 2703| | if constexpr (I == 0 || Opts.prettify) { 2704| | static constexpr auto quoted_key = join_v, chars<"null">>; 2705| | static constexpr auto n = quoted_key.size(); 2706| | std::memcpy(&b[ix], quoted_key.data(), n); 2707| | ix += n; 2708| | } 2709| | else { 2710| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2711| | static constexpr auto n = quoted_key.size(); 2712| | std::memcpy(&b[ix], quoted_key.data(), n); 2713| | ix += n; 2714| | } 2715| | } 2716| 101| else { 2717| | if constexpr (I == 0 || Opts.prettify) { 2718| | static constexpr auto quoted_key = quoted_key_v; 2719| | static constexpr auto n = quoted_key.size(); 2720| | std::memcpy(&b[ix], quoted_key.data(), n); 2721| | ix += n; 2722| | } 2723| 101| else { 2724| 101| static constexpr auto quoted_key = join_v, quoted_key_v>; 2725| 101| static constexpr auto n = quoted_key.size(); 2726| 101| std::memcpy(&b[ix], quoted_key.data(), n); 2727| 101| ix += n; 2728| 101| } 2729| | 2730| 101| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2730:57): [Folded, False: 101] ------------------ 2731| 101| if constexpr (reflectable) { 2732| 101| to::template op(get_member(value, get(t)), ctx, b, ix); 2733| | } 2734| | else { 2735| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2736| | ix); 2737| | } 2738| 101| } 2739| 101| }); _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm4EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _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_: 1435| 146| { 1436| 146| if (empty_range(value)) { ------------------ | Branch (1436:14): [True: 146, False: 0] ------------------ 1437| 146| dump("[]", b, ix); 1438| 146| } 1439| 0| else { 1440| | // For bounded buffers, skip pre-allocation path since value_padding is for SIMD, not actual size 1441| 0| if constexpr (has_size && array_padding_known && !has_bounded_capacity) { 1442| 0| const auto n = value.size(); 1443| | 1444| 0| static constexpr auto value_padding = []() -> size_t { 1445| 0| if constexpr (required_padding() > 0) 1446| 0| return required_padding(); 1447| 0| else 1448| 0| return fixed_padding; 1449| 0| }(); 1450| | 1451| | if constexpr (Opts.prettify) { 1452| | if constexpr (check_new_lines_in_arrays(Opts)) { 1453| | ctx.depth += check_indentation_width(Opts); 1454| | } 1455| | 1456| | // add space for '\n' and ',' characters for each element, hence `+ 2` 1457| | // use n + 1 because we put the end array character after the last element with whitespace 1458| | if (!ensure_space(ctx, b, ix + (n + 1) * (value_padding + ctx.depth + 2) + write_padding_bytes)) 1459| | [[unlikely]] { 1460| | return; 1461| | } 1462| | 1463| | if constexpr (check_new_lines_in_arrays(Opts)) { 1464| | std::memcpy(&b[ix], "[\n", 2); 1465| | ix += 2; 1466| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1467| | ix += ctx.depth; 1468| | } 1469| | else { 1470| | std::memcpy(&b[ix], "[", 1); 1471| | ++ix; 1472| | } 1473| | } 1474| 0| else { 1475| 0| static constexpr auto comma_padding = 1; 1476| 0| if (!ensure_space(ctx, b, ix + n * (value_padding + comma_padding) + write_padding_bytes)) ------------------ | Branch (1476:23): [True: 0, False: 0] ------------------ 1477| 0| [[unlikely]] { 1478| 0| return; 1479| 0| } 1480| 0| std::memcpy(&b[ix], "[", 1); 1481| 0| ++ix; 1482| 0| } 1483| | 1484| 0| auto it = std::begin(value); 1485| 0| using val_t = std::remove_cvref_t; 1486| 0| to::template op()>(*it, ctx, b, ix); 1487| | 1488| 0| ++it; 1489| 0| for (const auto fin = std::end(value); it != fin; ++it) { ------------------ | Branch (1489:55): [True: 0, False: 0] ------------------ 1490| | if constexpr (Opts.prettify) { 1491| | if constexpr (check_new_lines_in_arrays(Opts)) { 1492| | std::memcpy(&b[ix], ",\n", 2); 1493| | ix += 2; 1494| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1495| | ix += ctx.depth; 1496| | } 1497| | else { 1498| | std::memcpy(&b[ix], ", ", 2); 1499| | ix += 2; 1500| | } 1501| | } 1502| 0| else { 1503| 0| std::memcpy(&b[ix], ",", 1); 1504| 0| ++ix; 1505| 0| } 1506| | if constexpr (is_output_streaming) { 1507| | flush_buffer(b, ix); 1508| | } 1509| | 1510| 0| to::template op()>(*it, ctx, b, ix); 1511| 0| } 1512| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1513| | ctx.depth -= check_indentation_width(Opts); 1514| | std::memcpy(&b[ix], "\n", 1); 1515| | ++ix; 1516| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1517| | ix += ctx.depth; 1518| | } 1519| | 1520| 0| std::memcpy(&b[ix], "]", 1); 1521| 0| ++ix; 1522| | } 1523| | else { 1524| | // we either can't get the size (std::forward_list) or we cannot compute the allocation size 1525| | 1526| | if constexpr (Opts.prettify) { 1527| | if constexpr (check_new_lines_in_arrays(Opts)) { 1528| | ctx.depth += check_indentation_width(Opts); 1529| | } 1530| | 1531| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1532| | return; 1533| | } 1534| | 1535| | if constexpr (check_new_lines_in_arrays(Opts)) { 1536| | std::memcpy(&b[ix], "[\n", 2); 1537| | ix += 2; 1538| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1539| | ix += ctx.depth; 1540| | } 1541| | else { 1542| | std::memcpy(&b[ix], "[", 1); 1543| | ++ix; 1544| | } 1545| | } 1546| | else { 1547| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1548| | return; 1549| | } 1550| | std::memcpy(&b[ix], "[", 1); 1551| | ++ix; 1552| | } 1553| | 1554| | auto it = std::begin(value); 1555| | using val_t = std::remove_cvref_t; 1556| | if constexpr (required_padding()) { 1557| | to::template op()>(*it, ctx, b, ix); 1558| | } 1559| | else { 1560| | to::template op(*it, ctx, b, ix); 1561| | if (bool(ctx.error)) [[unlikely]] { 1562| | return; 1563| | } 1564| | } 1565| | 1566| | ++it; 1567| | for (const auto fin = std::end(value); it != fin; ++it) { 1568| | if constexpr (required_padding()) { 1569| | if constexpr (Opts.prettify) { 1570| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1571| | return; 1572| | } 1573| | } 1574| | else { 1575| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1576| | return; 1577| | } 1578| | } 1579| | 1580| | if constexpr (Opts.prettify) { 1581| | if constexpr (check_new_lines_in_arrays(Opts)) { 1582| | std::memcpy(&b[ix], ",\n", 2); 1583| | ix += 2; 1584| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1585| | ix += ctx.depth; 1586| | } 1587| | else { 1588| | std::memcpy(&b[ix], ", ", 2); 1589| | ix += 2; 1590| | } 1591| | } 1592| | else { 1593| | std::memcpy(&b[ix], ",", 1); 1594| | ++ix; 1595| | } 1596| | if constexpr (is_output_streaming) { 1597| | flush_buffer(b, ix); 1598| | } 1599| | 1600| | to::template op()>(*it, ctx, b, ix); 1601| | } 1602| | else { 1603| | write_array_entry_separator(ctx, b, ix); 1604| | to::template op(*it, ctx, b, ix); 1605| | if (bool(ctx.error)) [[unlikely]] { 1606| | return; 1607| | } 1608| | } 1609| | } 1610| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1611| | ctx.depth -= check_indentation_width(Opts); 1612| | dump_newline_indent(check_indentation_char(Opts), ctx.depth, b, ix); 1613| | } 1614| | 1615| | dump(']', b, ix); 1616| | } 1617| 0| } 1618| 146| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm5EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _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_: 1623| 100| { 1624| 100| if constexpr (not check_opening_handled(Opts)) { 1625| 100| dump('{', b, ix); 1626| 100| } 1627| | 1628| 100| if (!empty_range(value)) { ------------------ | Branch (1628:14): [True: 0, False: 100] ------------------ 1629| 0| if constexpr (!check_opening_handled(Opts)) { 1630| | if constexpr (Opts.prettify) { 1631| | ctx.depth += check_indentation_width(Opts); 1632| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1633| | return; 1634| | } 1635| | std::memcpy(&b[ix], "\n", 1); 1636| | ++ix; 1637| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1638| | ix += ctx.depth; 1639| | } 1640| 0| } 1641| | 1642| 0| using val_t = detail::iterator_second_type; // the type of value in each [key, value] pair 1643| 0| if constexpr (!never_written) { 1644| | if constexpr (null_t && Opts.skip_null_members) { 1645| | auto write_first_entry = [&](auto&& it) { 1646| | auto&& [key, entry_val] = *it; 1647| | if (skip_member(entry_val)) { 1648| | return true; 1649| | } 1650| | write_pair_content(key, entry_val, ctx, b, ix); 1651| | return bool(ctx.error); 1652| | }; 1653| | 1654| | auto it = std::begin(value); 1655| | bool first = write_first_entry(it); 1656| | if (bool(ctx.error)) [[unlikely]] { 1657| | return; 1658| | } 1659| | ++it; 1660| | for (const auto end = std::end(value); it != end; ++it) { 1661| | auto&& [key, entry_val] = *it; 1662| | if (skip_member(entry_val)) { 1663| | continue; 1664| | } 1665| | 1666| | // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be 1667| | // conditional for every entry. 1668| | // Alternatively, write separator after each entry except last but then branch is permanent 1669| | if (not first) { 1670| | write_object_entry_separator(ctx, b, ix); 1671| | } 1672| | 1673| | write_pair_content(key, entry_val, ctx, b, ix); 1674| | if (bool(ctx.error)) [[unlikely]] { 1675| | return; 1676| | } 1677| | 1678| | first = false; 1679| | } 1680| | } 1681| 0| else { 1682| 0| auto write_first_entry = [&](auto&& it) { 1683| 0| auto&& [key, entry_val] = *it; 1684| 0| write_pair_content(key, entry_val, ctx, b, ix); 1685| 0| }; 1686| | 1687| 0| auto it = std::begin(value); 1688| 0| write_first_entry(it); 1689| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1689:23): [True: 0, False: 0] ------------------ 1690| 0| return; 1691| 0| } 1692| 0| ++it; 1693| 0| for (const auto end = std::end(value); it != end; ++it) { ------------------ | Branch (1693:58): [True: 0, False: 0] ------------------ 1694| 0| auto&& [key, entry_val] = *it; 1695| 0| write_object_entry_separator(ctx, b, ix); 1696| 0| write_pair_content(key, entry_val, ctx, b, ix); 1697| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1697:26): [True: 0, False: 0] ------------------ 1698| 0| return; 1699| 0| } 1700| 0| } 1701| 0| } 1702| 0| } 1703| | 1704| 0| if constexpr (!check_closing_handled(Opts)) { 1705| | if constexpr (Opts.prettify) { 1706| | ctx.depth -= check_indentation_width(Opts); 1707| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1708| | return; 1709| | } 1710| | std::memcpy(&b[ix], "\n", 1); 1711| | ++ix; 1712| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 1713| | ix += ctx.depth; 1714| | } 1715| 0| } 1716| 0| } 1717| | 1718| 100| if constexpr (!check_closing_handled(Opts)) { 1719| 100| dump('}', b, ix); 1720| 100| } 1721| 100| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| 60| if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| 60| else { 2572| 60| const auto is_null = [&]() { 2573| 60| decltype(auto) element = [&]() -> decltype(auto) { 2574| 60| if constexpr (reflectable) { 2575| 60| return get(t); 2576| 60| } 2577| 60| else { 2578| 60| return get(reflect::values); 2579| 60| } 2580| 60| }; 2581| | 2582| 60| if constexpr (nullable_wrapper) { 2583| 60| return !bool(element()(value).val); 2584| 60| } 2585| 60| else if constexpr (nullable_value_t) { 2586| 60| return !get_member(value, element()).has_value(); 2587| 60| } 2588| 60| else { 2589| 60| return !bool(get_member(value, element())); 2590| 60| } 2591| 60| }(); 2592| 60| if (is_null) return; ------------------ | Branch (2592:32): [True: 60, False: 0] ------------------ 2593| 60| } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| | if (is_glaze_value_field_null(value, t)) return; 2601| | } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [True: 0, Folded] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _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: 2572| 60| const auto is_null = [&]() { 2573| 60| decltype(auto) element = [&]() -> decltype(auto) { 2574| 60| if constexpr (reflectable) { 2575| 60| return get(t); 2576| 60| } 2577| 60| else { 2578| 60| return get(reflect::values); 2579| 60| } 2580| 60| }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| 60| else if constexpr (nullable_value_t) { 2586| 60| return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| 60| }(); _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: 2573| 60| decltype(auto) element = [&]() -> decltype(auto) { 2574| 60| if constexpr (reflectable) { 2575| 60| return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| 60| }; _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm7EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1955| 114| { 1956| | // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are 1957| | // written side by side whatever the alternative is. The visit below still instantiates in 1958| | // that mode (`if constexpr` does not discard the statements after it), but both of its 1959| | // tagged branches are compile-time dead there and the runtime `return` keeps it unreached. 1960| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) { 1961| | write_adjacent(value, ctx, b, ix); 1962| | return; 1963| | } 1964| 114| std::visit( 1965| 114| [&](auto&& val) { 1966| 114| using V = std::decay_t; 1967| | 1968| 114| if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| 114| custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| 114| if (missing_id(value, ctx)) { 1980| 114| return; 1981| 114| } 1982| 114| using id_type = std::decay_t[value.index()])>; 1983| 114| if constexpr (Opts.prettify) { 1984| 114| dump("{\n", b, ix); 1985| 114| ctx.depth += check_indentation_width(Opts); 1986| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| 114| dump('"', b, ix); 1988| 114| dump_maybe_empty(tag_v, b, ix); 1989| 114| if constexpr (std::integral) { 1990| 114| dump("\": ", b, ix); 1991| 114| serialize::op(ids_v[value.index()], ctx, b, ix); 1992| 114| } 1993| 114| else { 1994| 114| dump("\": \"", b, ix); 1995| 114| dump_maybe_empty(ids_v[value.index()], b, ix); 1996| 114| dump('"', b, ix); 1997| 114| } 1998| 114| const auto pos_after_tag = ix; 1999| 114| dump(",\n", b, ix); 2000| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| 114| const auto pos_body_start = ix; 2002| 114| to::template op()>(val, ctx, b, ix); 2003| 114| if (ix == pos_body_start) { 2004| 114| ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| 114| } 2006| 114| ctx.depth -= check_indentation_width(Opts); 2007| 114| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| 114| return; 2009| 114| } 2010| 114| std::memcpy(&b[ix], "\n", 1); 2011| 114| ++ix; 2012| 114| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| 114| ix += ctx.depth; 2014| 114| std::memcpy(&b[ix], "}", 1); 2015| 114| ++ix; 2016| 114| } 2017| 114| else { 2018| 114| dump("{\"", b, ix); 2019| 114| dump_maybe_empty(tag_v, b, ix); 2020| 114| if constexpr (std::integral) { 2021| 114| dump("\":", b, ix); 2022| 114| serialize::op(ids_v[value.index()], ctx, b, ix); 2023| 114| } 2024| 114| else { 2025| 114| dump("\":\"", b, ix); 2026| 114| dump_maybe_empty(ids_v[value.index()], b, ix); 2027| 114| dump('"', b, ix); 2028| 114| } 2029| 114| const auto pos_after_tag = ix; 2030| 114| dump(',', b, ix); 2031| 114| const auto pos_body_start = ix; 2032| 114| to::template op()>(val, ctx, b, ix); 2033| 114| if (ix == pos_body_start) { 2034| 114| ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| 114| } 2036| 114| dump('}', b, ix); 2037| 114| } 2038| 114| } 2039| 114| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| 114| variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| 114| if (missing_id(value, ctx)) { 2044| 114| return; 2045| 114| } 2046| 114| if constexpr (Opts.prettify) { 2047| 114| dump("{\n", b, ix); 2048| 114| ctx.depth += check_indentation_width(Opts); 2049| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| 114| dump('"', b, ix); 2051| 114| dump_maybe_empty(tag_v, b, ix); 2052| 114| dump("\": ", b, ix); 2053| 114| write_id(value, ctx, b, ix); 2054| 114| ctx.depth -= check_indentation_width(Opts); 2055| 114| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| 114| return; 2057| 114| } 2058| 114| std::memcpy(&b[ix], "\n", 1); 2059| 114| ++ix; 2060| 114| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| 114| ix += ctx.depth; 2062| 114| std::memcpy(&b[ix], "}", 1); 2063| 114| ++ix; 2064| 114| } 2065| 114| else { 2066| 114| dump("{\"", b, ix); 2067| 114| dump_maybe_empty(tag_v, b, ix); 2068| 114| dump("\":", b, ix); 2069| 114| write_id(value, ctx, b, ix); 2070| 114| dump('}', b, ix); 2071| 114| } 2072| 114| } 2073| 114| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| 114| (glaze_object_t || reflectable || is_memory_object) && 2075| 114| (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| 114| if (missing_id(value, ctx)) { 2081| 114| return; 2082| 114| } 2083| 114| constexpr auto N = []() { 2084| 114| if constexpr (is_memory_object) { 2085| 114| return reflect>::size; 2086| 114| } 2087| 114| else { 2088| 114| return reflect::size; 2089| 114| } 2090| 114| }(); 2091| | 2092| | // must first write out type 2093| 114| if constexpr (Opts.prettify) { 2094| 114| dump("{\n", b, ix); 2095| 114| ctx.depth += check_indentation_width(Opts); 2096| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| 114| dump('"', b, ix); 2098| 114| dump_maybe_empty(tag_v, b, ix); 2099| | 2100| 114| using id_type = std::decay_t[value.index()])>; 2101| | 2102| 114| if constexpr (std::integral) { 2103| 114| dump("\": ", b, ix); 2104| 114| serialize::op(ids_v[value.index()], ctx, b, ix); 2105| 114| if constexpr (N > 0) { 2106| 114| dump(",\n", b, ix); 2107| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| 114| } 2109| 114| } 2110| 114| else { 2111| 114| dump("\": \"", b, ix); 2112| 114| dump_maybe_empty(ids_v[value.index()], b, ix); 2113| 114| if constexpr (N == 0) { 2114| 114| dump('"', b, ix); 2115| 114| } 2116| 114| else { 2117| 114| dump("\",\n", b, ix); 2118| 114| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| 114| } 2120| 114| } 2121| 114| } 2122| 114| else { 2123| 114| using id_type = std::decay_t[value.index()])>; 2124| | 2125| 114| dump("{\"", b, ix); 2126| 114| dump_maybe_empty(tag_v, b, ix); 2127| | 2128| 114| if constexpr (std::integral) { 2129| 114| dump("\":", b, ix); 2130| 114| serialize::op(ids_v[value.index()], ctx, b, ix); 2131| 114| if constexpr (N > 0) { 2132| 114| dump(',', b, ix); 2133| 114| } 2134| 114| } 2135| 114| else { 2136| 114| dump("\":\"", b, ix); 2137| 114| dump_maybe_empty(ids_v[value.index()], b, ix); 2138| 114| if constexpr (N == 0) { 2139| 114| dump('"', b, ix); 2140| 114| } 2141| 114| else { 2142| 114| dump("\",", b, ix); 2143| 114| } 2144| 114| } 2145| 114| } 2146| 114| if constexpr (is_memory_object) { 2147| 114| if (!val) [[unlikely]] { 2148| 114| ctx.error = error_code::invalid_variant_object; 2149| 114| return; 2150| 114| } 2151| 114| to>::template op()>(*val, ctx, b, ix); 2152| 114| } 2153| 114| else { 2154| 114| to::template op()>(val, ctx, b, ix); 2155| 114| } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| 114| if constexpr (Opts.skip_null_members) { 2158| 114| if (b[ix - 1] == ',') { 2159| 114| --ix; 2160| 114| } 2161| 114| } 2162| | 2163| 114| if constexpr (Opts.prettify) { 2164| 114| ctx.depth -= check_indentation_width(Opts); 2165| 114| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| 114| return; 2167| 114| } 2168| 114| std::memcpy(&b[ix], "\n", 1); 2169| 114| ++ix; 2170| 114| fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| 114| ix += ctx.depth; 2172| 114| std::memcpy(&b[ix], "}", 1); 2173| 114| ++ix; 2174| 114| } 2175| 114| else { 2176| 114| dump('}', b, ix); 2177| 114| } 2178| 114| } 2179| 114| else { 2180| 114| to::template op(val, ctx, b, ix); 2181| 114| } 2182| 114| }, 2183| 114| value); 2184| 114| } _ZZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clISF_EEDaSS_: 1965| 114| [&](auto&& val) { 1966| 114| using V = std::decay_t; 1967| | 1968| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1969| | custom_write) { 1970| | // Custom alternative: the user's serializer emits the object body, into which we 1971| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1972| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1973| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1974| | // scalar/array, or that ignores those flags, would yield malformed output. 1975| | // 1976| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1977| | // two in sync. The body size is not known at compile time, so we always write the 1978| | // tag separator and then drop it at runtime if the body turned out empty. 1979| | if (missing_id(value, ctx)) { 1980| | return; 1981| | } 1982| | using id_type = std::decay_t[value.index()])>; 1983| | if constexpr (Opts.prettify) { 1984| | dump("{\n", b, ix); 1985| | ctx.depth += check_indentation_width(Opts); 1986| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1987| | dump('"', b, ix); 1988| | dump_maybe_empty(tag_v, b, ix); 1989| | if constexpr (std::integral) { 1990| | dump("\": ", b, ix); 1991| | serialize::op(ids_v[value.index()], ctx, b, ix); 1992| | } 1993| | else { 1994| | dump("\": \"", b, ix); 1995| | dump_maybe_empty(ids_v[value.index()], b, ix); 1996| | dump('"', b, ix); 1997| | } 1998| | const auto pos_after_tag = ix; 1999| | dump(",\n", b, ix); 2000| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2001| | const auto pos_body_start = ix; 2002| | to::template op()>(val, ctx, b, ix); 2003| | if (ix == pos_body_start) { 2004| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2005| | } 2006| | ctx.depth -= check_indentation_width(Opts); 2007| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2008| | return; 2009| | } 2010| | std::memcpy(&b[ix], "\n", 1); 2011| | ++ix; 2012| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2013| | ix += ctx.depth; 2014| | std::memcpy(&b[ix], "}", 1); 2015| | ++ix; 2016| | } 2017| | else { 2018| | dump("{\"", b, ix); 2019| | dump_maybe_empty(tag_v, b, ix); 2020| | if constexpr (std::integral) { 2021| | dump("\":", b, ix); 2022| | serialize::op(ids_v[value.index()], ctx, b, ix); 2023| | } 2024| | else { 2025| | dump("\":\"", b, ix); 2026| | dump_maybe_empty(ids_v[value.index()], b, ix); 2027| | dump('"', b, ix); 2028| | } 2029| | const auto pos_after_tag = ix; 2030| | dump(',', b, ix); 2031| | const auto pos_body_start = ix; 2032| | to::template op()>(val, ctx, b, ix); 2033| | if (ix == pos_body_start) { 2034| | ix = pos_after_tag; // custom body was empty: undo the tag separator 2035| | } 2036| | dump('}', b, ix); 2037| | } 2038| | } 2039| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2040| | variant_unit_alternative) { 2041| | // A unit alternative carries no data, so internal tagging renders it as the 2042| | // discriminator alone -- the same object an empty struct alternative produces. 2043| | if (missing_id(value, ctx)) { 2044| | return; 2045| | } 2046| | if constexpr (Opts.prettify) { 2047| | dump("{\n", b, ix); 2048| | ctx.depth += check_indentation_width(Opts); 2049| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2050| | dump('"', b, ix); 2051| | dump_maybe_empty(tag_v, b, ix); 2052| | dump("\": ", b, ix); 2053| | write_id(value, ctx, b, ix); 2054| | ctx.depth -= check_indentation_width(Opts); 2055| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2056| | return; 2057| | } 2058| | std::memcpy(&b[ix], "\n", 1); 2059| | ++ix; 2060| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2061| | ix += ctx.depth; 2062| | std::memcpy(&b[ix], "}", 1); 2063| | ++ix; 2064| | } 2065| | else { 2066| | dump("{\"", b, ix); 2067| | dump_maybe_empty(tag_v, b, ix); 2068| | dump("\":", b, ix); 2069| | write_id(value, ctx, b, ix); 2070| | dump('}', b, ix); 2071| | } 2072| | } 2073| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 2074| | (glaze_object_t || reflectable || is_memory_object) && 2075| | (not alternative_declares_key(tag_v))) { 2076| | // An alternative that declares a member named like the discriminator carries the 2077| | // discriminator itself, so no tag is merged here and the bare-write branch below 2078| | // handles it. Previously only `reflectable` alternatives were excluded; a 2079| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 2080| | if (missing_id(value, ctx)) { 2081| | return; 2082| | } 2083| | constexpr auto N = []() { 2084| | if constexpr (is_memory_object) { 2085| | return reflect>::size; 2086| | } 2087| | else { 2088| | return reflect::size; 2089| | } 2090| | }(); 2091| | 2092| | // must first write out type 2093| | if constexpr (Opts.prettify) { 2094| | dump("{\n", b, ix); 2095| | ctx.depth += check_indentation_width(Opts); 2096| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2097| | dump('"', b, ix); 2098| | dump_maybe_empty(tag_v, b, ix); 2099| | 2100| | using id_type = std::decay_t[value.index()])>; 2101| | 2102| | if constexpr (std::integral) { 2103| | dump("\": ", b, ix); 2104| | serialize::op(ids_v[value.index()], ctx, b, ix); 2105| | if constexpr (N > 0) { 2106| | dump(",\n", b, ix); 2107| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2108| | } 2109| | } 2110| | else { 2111| | dump("\": \"", b, ix); 2112| | dump_maybe_empty(ids_v[value.index()], b, ix); 2113| | if constexpr (N == 0) { 2114| | dump('"', b, ix); 2115| | } 2116| | else { 2117| | dump("\",\n", b, ix); 2118| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 2119| | } 2120| | } 2121| | } 2122| | else { 2123| | using id_type = std::decay_t[value.index()])>; 2124| | 2125| | dump("{\"", b, ix); 2126| | dump_maybe_empty(tag_v, b, ix); 2127| | 2128| | if constexpr (std::integral) { 2129| | dump("\":", b, ix); 2130| | serialize::op(ids_v[value.index()], ctx, b, ix); 2131| | if constexpr (N > 0) { 2132| | dump(',', b, ix); 2133| | } 2134| | } 2135| | else { 2136| | dump("\":\"", b, ix); 2137| | dump_maybe_empty(ids_v[value.index()], b, ix); 2138| | if constexpr (N == 0) { 2139| | dump('"', b, ix); 2140| | } 2141| | else { 2142| | dump("\",", b, ix); 2143| | } 2144| | } 2145| | } 2146| | if constexpr (is_memory_object) { 2147| | if (!val) [[unlikely]] { 2148| | ctx.error = error_code::invalid_variant_object; 2149| | return; 2150| | } 2151| | to>::template op()>(*val, ctx, b, ix); 2152| | } 2153| | else { 2154| | to::template op()>(val, ctx, b, ix); 2155| | } 2156| | // If we skip everything then we may have an extra comma, which we want to revert 2157| | if constexpr (Opts.skip_null_members) { 2158| | if (b[ix - 1] == ',') { 2159| | --ix; 2160| | } 2161| | } 2162| | 2163| | if constexpr (Opts.prettify) { 2164| | ctx.depth -= check_indentation_width(Opts); 2165| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2166| | return; 2167| | } 2168| | std::memcpy(&b[ix], "\n", 1); 2169| | ++ix; 2170| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2171| | ix += ctx.depth; 2172| | std::memcpy(&b[ix], "}", 1); 2173| | ++ix; 2174| | } 2175| | else { 2176| | dump('}', b, ix); 2177| | } 2178| | } 2179| 114| else { 2180| 114| to::template op(val, ctx, b, ix); 2181| 114| } 2182| 114| }, _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm8EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1275| 60| { 1276| 60| static constexpr auto name = name_v>; 1277| 60| constexpr auto n = name.size(); 1278| | 1279| 60| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1279:14): [True: 0, False: 60] ------------------ 1280| 0| return; 1281| 0| } 1282| | 1283| 60| std::memcpy(&b[ix], "\"", 1); 1284| 60| ++ix; 1285| 60| if constexpr (not name.empty()) { 1286| 60| std::memcpy(&b[ix], name.data(), n); 1287| 60| ix += n; 1288| 60| } 1289| 60| std::memcpy(&b[ix], "\"", 1); 1290| 60| ++ix; 1291| 60| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm9EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSC_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1275| 60| { 1276| 60| static constexpr auto name = name_v>; 1277| 60| constexpr auto n = name.size(); 1278| | 1279| 60| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1279:14): [True: 0, False: 60] ------------------ 1280| 0| return; 1281| 0| } 1282| | 1283| 60| std::memcpy(&b[ix], "\"", 1); 1284| 60| ++ix; 1285| 60| if constexpr (not name.empty()) { 1286| 60| std::memcpy(&b[ix], name.data(), n); 1287| 60| ix += n; 1288| 60| } 1289| 60| std::memcpy(&b[ix], "\"", 1); 1290| 60| ++ix; 1291| 60| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm10EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__18functionIFN12jsonrpc_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS8_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1275| 60| { 1276| 60| static constexpr auto name = name_v>; 1277| 60| constexpr auto n = name.size(); 1278| | 1279| 60| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1279:14): [True: 0, False: 60] ------------------ 1280| 0| return; 1281| 0| } 1282| | 1283| 60| std::memcpy(&b[ix], "\"", 1); 1284| 60| ++ix; 1285| 60| if constexpr (not name.empty()) { 1286| 60| std::memcpy(&b[ix], name.data(), n); 1287| 60| ix += n; 1288| 60| } 1289| 60| std::memcpy(&b[ix], "\"", 1); 1290| 60| ++ix; 1291| 60| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm11EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEERS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1275| 60| { 1276| 60| static constexpr auto name = name_v>; 1277| 60| constexpr auto n = name.size(); 1278| | 1279| 60| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1279:14): [True: 0, False: 60] ------------------ 1280| 0| return; 1281| 0| } 1282| | 1283| 60| std::memcpy(&b[ix], "\"", 1); 1284| 60| ++ix; 1285| 60| if constexpr (not name.empty()) { 1286| 60| std::memcpy(&b[ix], name.data(), n); 1287| 60| ix += n; 1288| 60| } 1289| 60| std::memcpy(&b[ix], "\"", 1); 1290| 60| ++ix; 1291| 60| } _ZZN3glz2toILj10EN12jsonrpc_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm12EEEDav: 2545| 60| for_each([&]() { 2546| 60| using val_t = field_t; 2547| | 2548| | // Compile-time exclusions gate the field here rather than returning early, so that a 2549| | // skipped field's writer is never instantiated -- see `skipped_by_meta`. 2550| | if constexpr (skipped_on_write) { 2551| | return; 2552| | } 2553| 60| else { 2554| | if constexpr (meta_has_skip_if) { 2555| | static constexpr auto skip_if_key = glz::get(reflect::keys); 2556| | static constexpr meta_context mctx{.op = operation::serialize}; 2557| | decltype(auto) field_value = [&]() -> decltype(auto) { 2558| | if constexpr (reflectable) { 2559| | return get(t); 2560| | } 2561| | else { 2562| | return get_member(value, glz::get(reflect::values)); 2563| | } 2564| | }(); 2565| | if (meta::skip_if(field_value, skip_if_key, mctx)) return; 2566| | } 2567| | 2568| | if constexpr (null_t && Opts.skip_null_members) { 2569| | if constexpr (always_null_t) 2570| | return; 2571| | else { 2572| | const auto is_null = [&]() { 2573| | decltype(auto) element = [&]() -> decltype(auto) { 2574| | if constexpr (reflectable) { 2575| | return get(t); 2576| | } 2577| | else { 2578| | return get(reflect::values); 2579| | } 2580| | }; 2581| | 2582| | if constexpr (nullable_wrapper) { 2583| | return !bool(element()(value).val); 2584| | } 2585| | else if constexpr (nullable_value_t) { 2586| | return !get_member(value, element()).has_value(); 2587| | } 2588| | else { 2589| | return !bool(get_member(value, element())); 2590| | } 2591| | }(); 2592| | if (is_null) return; 2593| | } 2594| | } 2595| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2596| | custom_getter_returns_nullable()) { 2597| | if (is_custom_field_null(value, t, ctx)) return; 2598| | } 2599| 60| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2600| 60| if (is_glaze_value_field_null(value, t)) return; 2601| 60| } 2602| | 2603| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2604| | decltype(auto) member = [&]() -> decltype(auto) { 2605| | if constexpr (reflectable) { 2606| | return get_member(value, get(t)); 2607| | } 2608| | else { 2609| | return get_member(value, get(reflect::values)); 2610| | } 2611| | }(); 2612| | if (is_default_value(member)) return; 2613| | } 2614| | 2615| | if constexpr (Opts.prettify) { 2616| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2617| | return; 2618| | } 2619| | } 2620| 60| else { 2621| 60| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2621:29): [True: 0, False: 60] ------------------ 2622| 0| return; 2623| 0| } 2624| 60| } 2625| | 2626| 60| if (first) { ------------------ | Branch (2626:26): [True: 0, False: 60] ------------------ 2627| 0| first = false; 2628| 0| } 2629| 60| else { 2630| | // Null members may be skipped so we can't just write it out for all but the last member 2631| | if constexpr (Opts.prettify) { 2632| | std::memcpy(&b[ix], ",\n", 2); 2633| | ix += 2; 2634| | fill_bytes(&b[ix], check_indentation_char(Opts), ctx.depth); 2635| | ix += ctx.depth; 2636| | } 2637| 60| else { 2638| 60| std::memcpy(&b[ix], ",", 1); 2639| 60| ++ix; 2640| 60| } 2641| | if constexpr (is_output_streaming) { 2642| | flush_buffer(b, ix); 2643| | } 2644| 60| } 2645| | 2646| | // MSVC requires get rather than keys[I] 2647| 60| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2648| 60| static constexpr auto quoted_key = quoted_key_v; 2649| 60| static constexpr auto n = quoted_key.size(); 2650| 60| std::memcpy(&b[ix], quoted_key.data(), n); 2651| 60| ix += n; 2652| | 2653| 60| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2653:57): [Folded, False: 60] ------------------ 2654| 60| if constexpr (reflectable) { 2655| 60| to::template op(get_member(value, get(t)), ctx, b, ix); 2656| | } 2657| | else { 2658| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2659| | ix); 2660| | } 2661| 60| } 2662| 60| }); _ZN3glz2toILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1275| 60| { 1276| 60| static constexpr auto name = name_v>; 1277| 60| constexpr auto n = name.size(); 1278| | 1279| 60| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1279:14): [True: 0, False: 60] ------------------ 1280| 0| return; 1281| 0| } 1282| | 1283| 60| std::memcpy(&b[ix], "\"", 1); 1284| 60| ++ix; 1285| 60| if constexpr (not name.empty()) { 1286| 60| std::memcpy(&b[ix], name.data(), n); 1287| 60| ix += n; 1288| 60| } 1289| 60| std::memcpy(&b[ix], "\"", 1); 1290| 60| ++ix; 1291| 60| } _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 814| 1.88k| { 815| 1.88k| if constexpr (not check_write_unchecked(Opts)) { 816| 1.88k| static_assert(required_padding()); 817| 1.88k| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (817:17): [True: 0, False: 1.88k] ------------------ 818| 0| return; 819| 0| } 820| 1.88k| } 821| | 822| 1.88k| 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.88k| else { 832| 1.88k| write_chars::op(value, ctx, b, ix); 833| 1.88k| } 834| 1.88k| } _ZN3glz16required_paddingIdEEmv: 538| 1.88k| { 539| 1.88k| constexpr auto value = []() -> size_t { 540| 1.88k| if constexpr (boolean_like) { 541| 1.88k| return 8; 542| 1.88k| } 543| 1.88k| else if constexpr (num_t) { 544| 1.88k| if constexpr (std::floating_point) { 545| 1.88k| if constexpr (sizeof(T) > 8) { 546| 1.88k| return 64; 547| 1.88k| } 548| 1.88k| else if constexpr (sizeof(T) > 4) { 549| | // zmij scratch + 4 for optional quotes and trailing comma. 550| 1.88k| return zmij::double_buffer_size + 4; 551| 1.88k| } 552| 1.88k| else { 553| 1.88k| return zmij::float_buffer_size + 4; 554| 1.88k| } 555| 1.88k| } 556| 1.88k| else if constexpr (sizeof(T) > 4) { 557| 1.88k| return 24; 558| 1.88k| } 559| 1.88k| else if constexpr (sizeof(T) > 2) { 560| 1.88k| return 16; 561| 1.88k| } 562| 1.88k| else { 563| 1.88k| return 8; 564| 1.88k| } 565| 1.88k| } 566| 1.88k| else if constexpr (nullable_like) { 567| 1.88k| if constexpr (has_value_type) { 568| 1.88k| return required_padding(); 569| 1.88k| } 570| 1.88k| else if constexpr (has_element_type) { 571| 1.88k| return required_padding(); 572| 1.88k| } 573| 1.88k| else { 574| 1.88k| return 0; 575| 1.88k| } 576| 1.88k| } 577| 1.88k| else if constexpr (always_null_t) { 578| 1.88k| return 8; 579| 1.88k| } 580| 1.88k| else { 581| 1.88k| return 0; 582| 1.88k| } 583| 1.88k| }(); 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.88k| return value; 591| 1.88k| } _ZN3glz2toILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEEvOT0_OT1_OT2_RT3_: 1813| 62| { 1814| 62| if (value) { ------------------ | Branch (1814:14): [True: 0, False: 62] ------------------ 1815| 0| if constexpr (required_padding()) { 1816| 0| serialize::op(*value, ctx, b, ix); 1817| | } 1818| | else { 1819| | serialize::op()>(*value, ctx, b, ix); 1820| | } 1821| 0| } 1822| 62| else { 1823| 62| dump("null", b, ix); 1824| 62| } 1825| 62| } _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS2_8expectedIS8_NS_9error_ctxEEEOT_: 2843| 4.26M| { 2844| 4.26M| return write(std::forward(value)); 2845| 4.26M| } _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 4.26M| { 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.26M| 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.26M| else { 945| 4.26M| const sv str = [&]() -> const sv { 946| 4.26M| if constexpr (array_char_t) { 947| 4.26M| return sv{value.data(), value.size()}; 948| 4.26M| } 949| 4.26M| else if constexpr (u8str_t) { 950| 4.26M| return sv{reinterpret_cast(value.data()), value.size()}; 951| 4.26M| } 952| 4.26M| else { 953| 4.26M| return str_view(value); 954| 4.26M| } 955| 4.26M| }(); 956| 4.26M| 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.26M| else { 988| | // Using the original sizing 989| 4.26M| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 4.26M] ------------------ 990| 0| return; 991| 0| } 992| 4.26M| } 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.26M| else { 1002| 4.26M| std::memcpy(&b[ix], "\"", 1); 1003| 4.26M| ++ix; 1004| | 1005| 4.26M| const auto* c = str.data(); 1006| 4.26M| const auto* const e = c + n; 1007| 4.26M| const auto start = &b[ix]; 1008| 4.26M| 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.26M| auto write_escape = [&]() { 1017| 4.26M| if constexpr (check_escape_control_characters(Opts)) { 1018| 4.26M| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 4.26M| std::memcpy(data, &escaped, 2); 1020| 4.26M| data += 2; 1021| 4.26M| } 1022| 4.26M| else { 1023| 4.26M| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 4.26M| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 4.26M| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 4.26M| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 4.26M| std::memcpy(data, unicode_escape, 6); 1028| 4.26M| data += 6; 1029| 4.26M| } 1030| 4.26M| } 1031| 4.26M| else { 1032| 4.26M| 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.26M| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 4.26M| ctx.error = error_code::invalid_control_character; 1040| 4.26M| } 1041| 4.26M| } 1042| 4.26M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 4.26M| data += 2; 1044| 4.26M| } 1045| 4.26M| ++c; 1046| 4.26M| }; 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.26M|#if defined(GLZ_USE_SSE2) 1055| 4.26M| 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.26M| if (n > 7) { ------------------ | Branch (1061:23): [True: 4.26M, False: 0] ------------------ 1062| 4.69M| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (1062:54): [True: 429k, False: 4.26M] ------------------ 1063| 429k| std::memcpy(data, c, 8); 1064| 429k| uint64_t swar; 1065| 429k| std::memcpy(&swar, c, 8); 1066| | if constexpr (std::endian::native == std::endian::big) { 1067| | swar = std::byteswap(swar); 1068| | } 1069| | 1070| 429k| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1071| 429k| const uint64_t lo7 = swar & lo7_mask; 1072| 429k| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1073| 429k| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1074| 429k| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1075| 429k| uint64_t next = ~((quote & backslash & less_32) | swar); 1076| | 1077| 429k| next &= repeat_byte8(0b10000000); 1078| 429k| if (next == 0) { ------------------ | Branch (1078:29): [True: 51.0k, False: 377k] ------------------ 1079| 51.0k| data += 8; 1080| 51.0k| c += 8; 1081| 51.0k| continue; 1082| 51.0k| } 1083| | 1084| 377k| const auto length = (countr_zero(next) >> 3); 1085| 377k| c += length; 1086| 377k| data += length; 1087| 377k| write_escape(); 1088| 377k| } 1089| 4.26M| } 1090| | 1091| | // Scalar tail 1092| 29.4M| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 25.1M, False: 4.26M] ------------------ 1093| 25.1M| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 56.3k, False: 25.1M] ------------------ 1094| 56.3k| std::memcpy(data, &escaped, 2); 1095| 56.3k| data += 2; 1096| 56.3k| } 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.1M| 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.1M| std::memcpy(data, c, 1); 1118| 25.1M| ++data; 1119| 25.1M| } 1120| 25.1M| } 1121| | 1122| 4.26M| ix += size_t(data - start); 1123| | 1124| 4.26M| std::memcpy(&b[ix], "\"", 1); 1125| 4.26M| ++ix; 1126| 4.26M| } 1127| 4.26M| } 1128| 4.26M| } 1129| 4.26M| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 4.26M| 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.26M| else { 953| 4.26M| return str_view(value); 954| 4.26M| } 955| 4.26M| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 1016| 1.29M| 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.29M| 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.29M| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 1.29M| data += 2; 1044| 1.29M| } 1045| 1.29M| ++c; 1046| 1.29M| }; _ZN3glz10write_jsonITkNS_15write_supportedIL_ZNS_4JSONEEEERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS2_8expectedINS2_12basic_stringIcS5_NS2_9allocatorIcEEEENS_9error_ctxEEEOT_: 2843| 70| { 2844| 70| return write(std::forward(value)); 2845| 70| } _ZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 845| 70| { 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| 70| 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| 70| else { 945| 70| const sv str = [&]() -> const sv { 946| 70| if constexpr (array_char_t) { 947| 70| return sv{value.data(), value.size()}; 948| 70| } 949| 70| else if constexpr (u8str_t) { 950| 70| return sv{reinterpret_cast(value.data()), value.size()}; 951| 70| } 952| 70| else { 953| 70| return str_view(value); 954| 70| } 955| 70| }(); 956| 70| 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| 70| else { 988| | // Using the original sizing 989| 70| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (989:23): [True: 0, False: 70] ------------------ 990| 0| return; 991| 0| } 992| 70| } 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| 70| else { 1002| 70| std::memcpy(&b[ix], "\"", 1); 1003| 70| ++ix; 1004| | 1005| 70| const auto* c = str.data(); 1006| 70| const auto* const e = c + n; 1007| 70| const auto start = &b[ix]; 1008| 70| 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| 70| auto write_escape = [&]() { 1017| 70| if constexpr (check_escape_control_characters(Opts)) { 1018| 70| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 1019| 70| std::memcpy(data, &escaped, 2); 1020| 70| data += 2; 1021| 70| } 1022| 70| else { 1023| 70| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 1024| 70| constexpr char hex_digits[] = "0123456789ABCDEF"; 1025| 70| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 1026| 70| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 1027| 70| std::memcpy(data, unicode_escape, 6); 1028| 70| data += 6; 1029| 70| } 1030| 70| } 1031| 70| else { 1032| 70| 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| 70| if (char_escape_table[uint8_t(*c)] == 0) [[unlikely]] { 1039| 70| ctx.error = error_code::invalid_control_character; 1040| 70| } 1041| 70| } 1042| 70| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 1043| 70| data += 2; 1044| 70| } 1045| 70| ++c; 1046| 70| }; 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| 70|#if defined(GLZ_USE_SSE2) 1055| 70| 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| 70| if (n > 7) { ------------------ | Branch (1061:23): [True: 0, False: 70] ------------------ 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| 490| for (; c < e; ++c) { ------------------ | Branch (1092:26): [True: 420, False: 70] ------------------ 1093| 420| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (1093:79): [True: 0, False: 420] ------------------ 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| 420| 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| 420| std::memcpy(data, c, 1); 1118| 420| ++data; 1119| 420| } 1120| 420| } 1121| | 1122| 70| ix += size_t(data - start); 1123| | 1124| 70| std::memcpy(&b[ix], "\"", 1); 1125| 70| ++ix; 1126| 70| } 1127| 70| } 1128| 70| } 1129| 70| } _ZZN3glz2toILj10ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERNS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKS5_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 945| 70| 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| 70| else { 953| 70| return str_view(value); 954| 70| } 955| 70| }(); _ZN3glz6to_tieIRN12jsonrpc_fuzz5pointELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 87.2k| { 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| 87.2k| else if constexpr (N == 2) { 146| 87.2k| auto& [p0, p1] = t; 147| 87.2k| 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| 87.2k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz8fuzz_apiELm13EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 112k| { 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| 112k| else if constexpr (N == 13) { 190| 112k| auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| 112k| 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| 112k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz6nestedELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 96.1k| { 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| 96.1k| else if constexpr (N == 2) { 146| 96.1k| auto& [p0, p1] = t; 147| 96.1k| 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| 96.1k| } _ZN3glz6to_tieIRN12jsonrpc_fuzz6amountELm1EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 329| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| 329| else if constexpr (N == 1) { 142| 329| auto& [p] = t; 143| 329| 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| 329| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 151| 79.7k| { 152| 79.7k| register_read_write_endpoint(path, value, reg); 153| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZNK3glz7jsonrpc5state8has_bodyEv: 28| 72.6k| bool has_body() const { return has_params; } _ZN3glz7jsonrpc11write_errorITkNS0_8is_stateERNS0_5stateEEEvOT_NS_3rpc7error_eERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEERKNS8_8optionalISE_EE: 76| 18.2k| { 77| 18.2k| if (state.notify()) { ------------------ | Branch (77:14): [True: 2.81k, False: 15.4k] ------------------ 78| 2.81k| return; // No response for notifications 79| 2.81k| } 80| | 81| 15.4k| state.response = R"({"jsonrpc":"2.0","error":{"code":)"; 82| 15.4k| state.response += std::to_string(static_cast(code)); 83| 15.4k| state.response += R"(,"message":)"; 84| 15.4k| state.response += write_json(message).value_or("\"\""); 85| 15.4k| if (data) { ------------------ | Branch (85:14): [True: 15.4k, False: 0] ------------------ 86| 15.4k| state.response += R"(,"data":)"; 87| 15.4k| state.response += write_json(*data).value_or("null"); 88| 15.4k| } 89| 15.4k| state.response += R"(},"id":)"; 90| 15.4k| state.response += write_json(state.id).value_or("null"); 91| 15.4k| state.response += "}"; 92| 15.4k| } _ZNK3glz7jsonrpc5state6notifyEv: 27| 57.0k| bool notify() const { return is_notification; } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS0_8is_stateERNS0_5stateEEEvOT0_: 63| 4.82k| { 64| 4.82k| if (state.notify()) { ------------------ | Branch (64:14): [True: 0, False: 4.82k] ------------------ 65| 0| return; // No response for notifications 66| 0| } 67| | 68| 4.82k| state.response = R"({"jsonrpc":"2.0","result":null,"id":)"; 69| 4.82k| state.response += write_json(state.id).value_or("null"); 70| 4.82k| state.response += "}"; 71| 4.82k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 241| 239k| { 242| 239k| register_read_write_endpoint(path, var, reg); 243| 239k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 127| 239k| { 128| 239k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 239k| if (state.has_body()) { 130| 239k| if (!jsonrpc::read_params(value, state)) { 131| 239k| return; 132| 239k| } 133| 239k| } 134| | 135| 239k| if (state.notify()) { 136| 239k| return; 137| 239k| } 138| | 139| 239k| if (!state.has_body()) { 140| 239k| jsonrpc::write_response(value, state); 141| 239k| } 142| 239k| else { 143| 239k| jsonrpc::write_response(state); 144| 239k| } 145| 239k| }; 146| 239k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_: 128| 958| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 958| if (state.has_body()) { ------------------ | Branch (129:17): [True: 365, False: 593] ------------------ 130| 365| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 257, False: 108] ------------------ 131| 257| return; 132| 257| } 133| 365| } 134| | 135| 701| if (state.notify()) { ------------------ | Branch (135:17): [True: 524, False: 177] ------------------ 136| 524| return; 137| 524| } 138| | 139| 177| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 96, False: 81] ------------------ 140| 96| jsonrpc::write_response(value, state); 141| 96| } 142| 81| else { 143| 81| jsonrpc::write_response(state); 144| 81| } 145| 177| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 2.30k| { 98| 2.30k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 927, False: 1.37k] ------------------ 99| 927| return true; // No params to read 100| 927| } 101| | 102| 1.37k| auto ec = read(std::forward(value), state.params_json); 103| 1.37k| if (ec) { ------------------ | Branch (103:14): [True: 692, False: 686] ------------------ 104| 692| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 692| return false; 106| 692| } 107| 686| return true; 108| 1.37k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 438| { 38| 438| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 438] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 438| std::string result_json; 43| 438| auto ec = write(std::forward(value), result_json); 44| 438| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 438] ------------------ 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| 438| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 438| state.response += result_json; 55| 438| state.response += R"(,"id":)"; 56| 438| state.response += write_json(state.id).value_or("null"); 57| 438| state.response += "}"; 58| 438| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE45register_member_function_with_params_endpointIN12jsonrpc_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_: 271| 79.7k| { 272| 79.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 79.7k| static thread_local Input input{}; 274| 79.7k| input = {}; // reset to avoid stale optional/variant fields across calls 275| 79.7k| if (state.has_body()) { 276| 79.7k| if (!jsonrpc::read_params(input, state)) { 277| 79.7k| return; 278| 79.7k| } 279| 79.7k| } 280| | 281| 79.7k| if constexpr (std::same_as) { 282| 79.7k| (value.*func)(input); 283| | 284| 79.7k| if (state.notify()) { 285| 79.7k| return; 286| 79.7k| } 287| | 288| 79.7k| jsonrpc::write_response(state); 289| 79.7k| } 290| 79.7k| else { 291| 79.7k| if (state.notify()) { 292| 79.7k| std::ignore = (value.*func)(input); 293| 79.7k| return; 294| 79.7k| } 295| | 296| 79.7k| jsonrpc::write_response((value.*func)(input), state); 297| 79.7k| } 298| 79.7k| }; 299| 79.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| 988| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 988| static thread_local Input input{}; 274| 988| input = {}; // reset to avoid stale optional/variant fields across calls 275| 988| if (state.has_body()) { ------------------ | Branch (275:17): [True: 486, False: 502] ------------------ 276| 486| if (!jsonrpc::read_params(input, state)) { ------------------ | Branch (276:20): [True: 200, False: 286] ------------------ 277| 200| return; 278| 200| } 279| 486| } 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| 788| else { 291| 788| if (state.notify()) { ------------------ | Branch (291:20): [True: 493, False: 295] ------------------ 292| 493| std::ignore = (value.*func)(input); 293| 493| return; 294| 493| } 295| | 296| 295| jsonrpc::write_response((value.*func)(input), state); 297| 295| } 298| 788| }; _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 295| { 38| 295| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 295] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 295| std::string result_json; 43| 295| auto ec = write(std::forward(value), result_json); 44| 295| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 295] ------------------ 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| 295| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 295| state.response += result_json; 55| 295| state.response += R"(,"id":)"; 56| 295| state.response += write_json(state.id).value_or("null"); 57| 295| state.response += "}"; 58| 295| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_: 247| 79.7k| { 248| 79.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 249| 79.7k| if constexpr (std::same_as) { 250| 79.7k| (value.*func)(); 251| | 252| 79.7k| if (state.notify()) { 253| 79.7k| return; 254| 79.7k| } 255| | 256| 79.7k| jsonrpc::write_response(state); 257| 79.7k| } 258| 79.7k| else { 259| 79.7k| if (state.notify()) { 260| 79.7k| std::ignore = (value.*func)(); 261| 79.7k| return; 262| 79.7k| } 263| | 264| 79.7k| jsonrpc::write_response((value.*func)(), state); 265| 79.7k| } 266| 79.7k| }; 267| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE33register_member_function_endpointIN12jsonrpc_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_ENUlONS_7jsonrpc5stateEE_clESM_: 248| 429| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 249| 429| if constexpr (std::same_as) { 250| 429| (value.*func)(); 251| | 252| 429| if (state.notify()) { ------------------ | Branch (252:20): [True: 351, False: 78] ------------------ 253| 351| return; 254| 351| } 255| | 256| 78| 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| 429| }; _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| 79.7k| { 272| 79.7k| reg.endpoints[path] = [&value, func](jsonrpc::state&& state) mutable { 273| 79.7k| static thread_local Input input{}; 274| 79.7k| input = {}; // reset to avoid stale optional/variant fields across calls 275| 79.7k| if (state.has_body()) { 276| 79.7k| if (!jsonrpc::read_params(input, state)) { 277| 79.7k| return; 278| 79.7k| } 279| 79.7k| } 280| | 281| 79.7k| if constexpr (std::same_as) { 282| 79.7k| (value.*func)(input); 283| | 284| 79.7k| if (state.notify()) { 285| 79.7k| return; 286| 79.7k| } 287| | 288| 79.7k| jsonrpc::write_response(state); 289| 79.7k| } 290| 79.7k| else { 291| 79.7k| if (state.notify()) { 292| 79.7k| std::ignore = (value.*func)(input); 293| 79.7k| return; 294| 79.7k| } 295| | 296| 79.7k| jsonrpc::write_response((value.*func)(input), state); 297| 79.7k| } 298| 79.7k| }; 299| 79.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: 533, False: 566] ------------------ 276| 533| if (!jsonrpc::read_params(input, state)) { ------------------ | Branch (276:20): [True: 465, False: 68] ------------------ 277| 465| return; 278| 465| } 279| 533| } 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| 634| else { 291| 634| if (state.notify()) { ------------------ | Branch (291:20): [True: 505, False: 129] ------------------ 292| 505| std::ignore = (value.*func)(input); 293| 505| return; 294| 505| } 295| | 296| 129| jsonrpc::write_response((value.*func)(input), state); 297| 129| } 298| 634| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 2.41k| { 98| 2.41k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 993, False: 1.42k] ------------------ 99| 993| return true; // No params to read 100| 993| } 101| | 102| 1.42k| auto ec = read(std::forward(value), state.params_json); 103| 1.42k| if (ec) { ------------------ | Branch (103:14): [True: 1.30k, False: 118] ------------------ 104| 1.30k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.30k| return false; 106| 1.30k| } 107| 118| return true; 108| 1.42k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 129| { 38| 129| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 129] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 129| std::string result_json; 43| 129| auto ec = write(std::forward(value), result_json); 44| 129| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 129] ------------------ 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| 129| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 129| state.response += result_json; 55| 129| state.response += R"(,"id":)"; 56| 129| state.response += write_json(state.id).value_or("null"); 57| 129| state.response += "}"; 58| 129| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE17register_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 151| 79.7k| { 152| 79.7k| register_read_write_endpoint(path, value, reg); 153| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 13.1k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 13.1k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 8.99k, False: 4.17k] ------------------ 130| 8.99k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 7.97k, False: 1.01k] ------------------ 131| 7.97k| return; 132| 7.97k| } 133| 8.99k| } 134| | 135| 5.18k| if (state.notify()) { ------------------ | Branch (135:17): [True: 4.30k, False: 887] ------------------ 136| 4.30k| return; 137| 4.30k| } 138| | 139| 887| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 60, False: 827] ------------------ 140| 60| jsonrpc::write_response(value, state); 141| 60| } 142| 827| else { 143| 827| jsonrpc::write_response(state); 144| 827| } 145| 887| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 8.99k| { 98| 8.99k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 8.99k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 8.99k| auto ec = read(std::forward(value), state.params_json); 103| 8.99k| if (ec) { ------------------ | Branch (103:14): [True: 7.97k, False: 1.01k] ------------------ 104| 7.97k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 7.97k| return false; 106| 7.97k| } 107| 1.01k| return true; 108| 8.99k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz8fuzz_apiETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 60| { 38| 60| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 60] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 60| std::string result_json; 43| 60| auto ec = write(std::forward(value), result_json); 44| 60| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 60] ------------------ 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| 60| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 60| state.response += result_json; 55| 60| state.response += R"(,"id":)"; 56| 60| state.response += write_json(state.id).value_or("null"); 57| 60| state.response += "}"; 58| 60| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_: 241| 159k| { 242| 159k| register_read_write_endpoint(path, var, reg); 243| 159k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_: 127| 159k| { 128| 159k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 159k| if (state.has_body()) { 130| 159k| if (!jsonrpc::read_params(value, state)) { 131| 159k| return; 132| 159k| } 133| 159k| } 134| | 135| 159k| if (state.notify()) { 136| 159k| return; 137| 159k| } 138| | 139| 159k| if (!state.has_body()) { 140| 159k| jsonrpc::write_response(value, state); 141| 159k| } 142| 159k| else { 143| 159k| jsonrpc::write_response(state); 144| 159k| } 145| 159k| }; 146| 159k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_: 128| 673| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 673| if (state.has_body()) { ------------------ | Branch (129:17): [True: 304, False: 369] ------------------ 130| 304| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 186, False: 118] ------------------ 131| 186| return; 132| 186| } 133| 304| } 134| | 135| 487| if (state.notify()) { ------------------ | Branch (135:17): [True: 366, False: 121] ------------------ 136| 366| return; 137| 366| } 138| | 139| 121| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 26, False: 95] ------------------ 140| 26| jsonrpc::write_response(value, state); 141| 26| } 142| 95| else { 143| 95| jsonrpc::write_response(state); 144| 95| } 145| 121| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 3.89k| { 98| 3.89k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 2.35k, False: 1.53k] ------------------ 99| 2.35k| return true; // No params to read 100| 2.35k| } 101| | 102| 1.53k| auto ec = read(std::forward(value), state.params_json); 103| 1.53k| if (ec) { ------------------ | Branch (103:14): [True: 779, False: 760] ------------------ 104| 779| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 779| return false; 106| 779| } 107| 760| return true; 108| 1.53k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 748| { 38| 748| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 748] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 748| std::string result_json; 43| 748| auto ec = write(std::forward(value), result_json); 44| 748| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 748] ------------------ 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| 748| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 748| state.response += result_json; 55| 748| state.response += R"(,"id":)"; 56| 748| state.response += write_json(state.id).value_or("null"); 57| 748| state.response += "}"; 58| 748| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 241| 159k| { 242| 159k| register_read_write_endpoint(path, var, reg); 243| 159k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 127| 159k| { 128| 159k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 159k| if (state.has_body()) { 130| 159k| if (!jsonrpc::read_params(value, state)) { 131| 159k| return; 132| 159k| } 133| 159k| } 134| | 135| 159k| if (state.notify()) { 136| 159k| return; 137| 159k| } 138| | 139| 159k| if (!state.has_body()) { 140| 159k| jsonrpc::write_response(value, state); 141| 159k| } 142| 159k| else { 143| 159k| jsonrpc::write_response(state); 144| 159k| } 145| 159k| }; 146| 159k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESH_: 128| 1.39k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 1.39k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 736, False: 661] ------------------ 130| 736| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 200, False: 536] ------------------ 131| 200| return; 132| 200| } 133| 736| } 134| | 135| 1.19k| if (state.notify()) { ------------------ | Branch (135:17): [True: 677, False: 520] ------------------ 136| 677| return; 137| 677| } 138| | 139| 520| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 25, False: 495] ------------------ 140| 25| jsonrpc::write_response(value, state); 141| 25| } 142| 495| else { 143| 495| jsonrpc::write_response(state); 144| 495| } 145| 520| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 736| { 98| 736| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 736] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 736| auto ec = read(std::forward(value), state.params_json); 103| 736| if (ec) { ------------------ | Branch (103:14): [True: 200, False: 536] ------------------ 104| 200| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 200| return false; 106| 200| } 107| 536| return true; 108| 736| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 1.88k| { 38| 1.88k| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 1.88k] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 1.88k| std::string result_json; 43| 1.88k| auto ec = write(std::forward(value), result_json); 44| 1.88k| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 1.88k] ------------------ 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.88k| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 1.88k| state.response += result_json; 55| 1.88k| state.response += R"(,"id":)"; 56| 1.88k| state.response += write_json(state.id).value_or("null"); 57| 1.88k| state.response += "}"; 58| 1.88k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 212| 79.7k| { 213| 79.7k| register_read_write_endpoint(path, obj, reg); 214| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 1.41k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 1.41k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 326, False: 1.08k] ------------------ 130| 326| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 313, False: 13] ------------------ 131| 313| return; 132| 313| } 133| 326| } 134| | 135| 1.09k| if (state.notify()) { ------------------ | Branch (135:17): [True: 965, False: 133] ------------------ 136| 965| return; 137| 965| } 138| | 139| 133| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 122, False: 11] ------------------ 140| 122| jsonrpc::write_response(value, state); 141| 122| } 142| 11| else { 143| 11| jsonrpc::write_response(state); 144| 11| } 145| 133| }; _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz5pointETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 259| { 38| 259| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 259] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 259| std::string result_json; 43| 259| auto ec = write(std::forward(value), result_json); 44| 259| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 259] ------------------ 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| 259| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 259| state.response += result_json; 55| 259| state.response += R"(,"id":)"; 56| 259| state.response += write_json(state.id).value_or("null"); 57| 259| state.response += "}"; 58| 259| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE24register_object_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 212| 79.7k| { 213| 79.7k| register_read_write_endpoint(path, obj, reg); 214| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointIN12jsonrpc_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 2.84k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.84k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.81k, False: 1.03k] ------------------ 130| 1.81k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.52k, False: 289] ------------------ 131| 1.52k| return; 132| 1.52k| } 133| 1.81k| } 134| | 135| 1.32k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.04k, False: 278] ------------------ 136| 1.04k| return; 137| 1.04k| } 138| | 139| 278| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 41, False: 237] ------------------ 140| 41| jsonrpc::write_response(value, state); 141| 41| } 142| 237| else { 143| 237| jsonrpc::write_response(state); 144| 237| } 145| 278| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.81k| { 98| 1.81k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.81k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.81k| auto ec = read(std::forward(value), state.params_json); 103| 1.81k| if (ec) { ------------------ | Branch (103:14): [True: 1.52k, False: 289] ------------------ 104| 1.52k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.52k| return false; 106| 1.52k| } 107| 289| return true; 108| 1.81k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN12jsonrpc_fuzz6nestedETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 41| { 38| 41| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 41] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 41| std::string result_json; 43| 41| auto ec = write(std::forward(value), result_json); 44| 41| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 41] ------------------ 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| 41| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 41| state.response += result_json; 55| 41| state.response += R"(,"id":)"; 56| 41| state.response += write_json(state.id).value_or("null"); 57| 41| state.response += "}"; 58| 41| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 241| 79.7k| { 242| 79.7k| register_read_write_endpoint(path, var, reg); 243| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESL_: 128| 3.31k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 3.31k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.93k, False: 1.38k] ------------------ 130| 1.93k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.49k, False: 442] ------------------ 131| 1.49k| return; 132| 1.49k| } 133| 1.93k| } 134| | 135| 1.82k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.30k, False: 519] ------------------ 136| 1.30k| return; 137| 1.30k| } 138| | 139| 519| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 86, False: 433] ------------------ 140| 86| jsonrpc::write_response(value, state); 141| 86| } 142| 433| else { 143| 433| jsonrpc::write_response(state); 144| 433| } 145| 519| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.93k| { 98| 1.93k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.93k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.93k| auto ec = read(std::forward(value), state.params_json); 103| 1.93k| if (ec) { ------------------ | Branch (103:14): [True: 1.49k, False: 442] ------------------ 104| 1.49k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.49k| return false; 106| 1.49k| } 107| 442| return true; 108| 1.93k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 86| { 38| 86| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 86] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 86| std::string result_json; 43| 86| auto ec = write(std::forward(value), result_json); 44| 86| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 86] ------------------ 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| 86| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 86| state.response += result_json; 55| 86| state.response += R"(,"id":)"; 56| 86| state.response += write_json(state.id).value_or("null"); 57| 86| state.response += "}"; 58| 86| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 241| 79.7k| { 242| 79.7k| register_read_write_endpoint(path, var, reg); 243| 79.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| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.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.54k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.54k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.64k, False: 901] ------------------ 130| 1.64k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 1.27k, False: 373] ------------------ 131| 1.27k| return; 132| 1.27k| } 133| 1.64k| } 134| | 135| 1.27k| if (state.notify()) { ------------------ | Branch (135:17): [True: 937, False: 337] ------------------ 136| 937| return; 137| 937| } 138| | 139| 337| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 40, False: 297] ------------------ 140| 40| jsonrpc::write_response(value, state); 141| 40| } 142| 297| else { 143| 297| jsonrpc::write_response(state); 144| 297| } 145| 337| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.64k| { 98| 1.64k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.64k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.64k| auto ec = read(std::forward(value), state.params_json); 103| 1.64k| if (ec) { ------------------ | Branch (103:14): [True: 1.27k, False: 373] ------------------ 104| 1.27k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.27k| return false; 106| 1.27k| } 107| 373| return true; 108| 1.64k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 40| { 38| 40| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 40] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 40| std::string result_json; 43| 40| auto ec = write(std::forward(value), result_json); 44| 40| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 40] ------------------ 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| 40| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 40| state.response += result_json; 55| 40| state.response += R"(,"id":)"; 56| 40| state.response += write_json(state.id).value_or("null"); 57| 40| state.response += "}"; 58| 40| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 241| 79.7k| { 242| 79.7k| register_read_write_endpoint(path, var, reg); 243| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlONS_7jsonrpc5stateEE_clESJ_: 128| 3.58k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 3.58k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 2.15k, False: 1.42k] ------------------ 130| 2.15k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 427, False: 1.72k] ------------------ 131| 427| return; 132| 427| } 133| 2.15k| } 134| | 135| 3.15k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.50k, False: 1.64k] ------------------ 136| 1.50k| return; 137| 1.50k| } 138| | 139| 1.64k| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 62, False: 1.58k] ------------------ 140| 62| jsonrpc::write_response(value, state); 141| 62| } 142| 1.58k| else { 143| 1.58k| jsonrpc::write_response(state); 144| 1.58k| } 145| 1.64k| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 2.15k| { 98| 2.15k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 2.15k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 2.15k| auto ec = read(std::forward(value), state.params_json); 103| 2.15k| if (ec) { ------------------ | Branch (103:14): [True: 427, False: 1.72k] ------------------ 104| 427| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 427| return false; 106| 427| } 107| 1.72k| return true; 108| 2.15k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 62| { 38| 62| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 62] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 62| std::string result_json; 43| 62| auto ec = write(std::forward(value), result_json); 44| 62| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 62] ------------------ 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| 62| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 62| state.response += result_json; 55| 62| state.response += R"(,"id":)"; 56| 62| state.response += write_json(state.id).value_or("null"); 57| 62| state.response += "}"; 58| 62| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_variable_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 241| 79.7k| { 242| 79.7k| register_read_write_endpoint(path, var, reg); 243| 79.7k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE28register_read_write_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 127| 79.7k| { 128| 79.7k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 79.7k| if (state.has_body()) { 130| 79.7k| if (!jsonrpc::read_params(value, state)) { 131| 79.7k| return; 132| 79.7k| } 133| 79.7k| } 134| | 135| 79.7k| if (state.notify()) { 136| 79.7k| return; 137| 79.7k| } 138| | 139| 79.7k| if (!state.has_body()) { 140| 79.7k| jsonrpc::write_response(value, state); 141| 79.7k| } 142| 79.7k| else { 143| 79.7k| jsonrpc::write_response(state); 144| 79.7k| } 145| 79.7k| }; 146| 79.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.35k| reg.endpoints[path] = [&value](jsonrpc::state&& state) mutable { 129| 2.35k| if (state.has_body()) { ------------------ | Branch (129:17): [True: 1.29k, False: 1.05k] ------------------ 130| 1.29k| if (!jsonrpc::read_params(value, state)) { ------------------ | Branch (130:20): [True: 823, False: 476] ------------------ 131| 823| return; 132| 823| } 133| 1.29k| } 134| | 135| 1.53k| if (state.notify()) { ------------------ | Branch (135:17): [True: 1.07k, False: 463] ------------------ 136| 1.07k| return; 137| 1.07k| } 138| | 139| 463| if (!state.has_body()) { ------------------ | Branch (139:17): [True: 54, False: 409] ------------------ 140| 54| jsonrpc::write_response(value, state); 141| 54| } 142| 409| else { 143| 409| jsonrpc::write_response(state); 144| 409| } 145| 463| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 1.29k| { 98| 1.29k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 0, False: 1.29k] ------------------ 99| 0| return true; // No params to read 100| 0| } 101| | 102| 1.29k| auto ec = read(std::forward(value), state.params_json); 103| 1.29k| if (ec) { ------------------ | Branch (103:14): [True: 823, False: 476] ------------------ 104| 823| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 823| return false; 106| 823| } 107| 476| return true; 108| 1.29k| } _ZN3glz7jsonrpc14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN12jsonrpc_fuzz6amountEEEETkNS0_8is_stateERNS0_5stateEEEvOT0_OT1_: 37| 54| { 38| 54| if (state.notify()) { ------------------ | Branch (38:14): [True: 0, False: 54] ------------------ 39| 0| return; // No response for notifications 40| 0| } 41| | 42| 54| std::string result_json; 43| 54| auto ec = write(std::forward(value), result_json); 44| 54| if (ec) { ------------------ | Branch (44:14): [True: 0, False: 54] ------------------ 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| 54| state.response = R"({"jsonrpc":"2.0","result":)"; 54| 54| state.response += result_json; 55| 54| state.response += R"(,"id":)"; 56| 54| state.response += write_json(state.id).value_or("null"); 57| 54| state.response += "}"; 58| 54| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 79.7k| { 181| 79.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 79.7k| static thread_local std::decay_t params{}; 183| 79.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 79.7k| if (!jsonrpc::read_params(params, state)) { 185| 79.7k| return; 186| 79.7k| } 187| | 188| 79.7k| using Result = std::invoke_result_t; 189| | 190| 79.7k| if (state.notify()) { 191| 79.7k| if constexpr (std::same_as) { 192| 79.7k| func(params); 193| 79.7k| } 194| 79.7k| else { 195| 79.7k| std::ignore = func(params); 196| 79.7k| } 197| 79.7k| return; 198| 79.7k| } 199| 79.7k| if constexpr (std::same_as) { 200| 79.7k| func(params); 201| 79.7k| jsonrpc::write_response(state); 202| 79.7k| } 203| 79.7k| else { 204| 79.7k| auto ret = func(params); 205| 79.7k| jsonrpc::write_response(ret, state); 206| 79.7k| } 207| 79.7k| }; 208| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_: 181| 1.45k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 1.45k| static thread_local std::decay_t params{}; 183| 1.45k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 1.45k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 235, False: 1.21k] ------------------ 185| 235| return; 186| 235| } 187| | 188| 1.21k| using Result = std::invoke_result_t; 189| | 190| 1.21k| if (state.notify()) { ------------------ | Branch (190:17): [True: 877, False: 342] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 877| else { 195| 877| std::ignore = func(params); 196| 877| } 197| 877| return; 198| 877| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 342| else { 204| 342| auto ret = func(params); 205| 342| jsonrpc::write_response(ret, state); 206| 342| } 207| 342| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_: 180| 79.7k| { 181| 79.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 79.7k| static thread_local std::decay_t params{}; 183| 79.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 79.7k| if (!jsonrpc::read_params(params, state)) { 185| 79.7k| return; 186| 79.7k| } 187| | 188| 79.7k| using Result = std::invoke_result_t; 189| | 190| 79.7k| if (state.notify()) { 191| 79.7k| if constexpr (std::same_as) { 192| 79.7k| func(params); 193| 79.7k| } 194| 79.7k| else { 195| 79.7k| std::ignore = func(params); 196| 79.7k| } 197| 79.7k| return; 198| 79.7k| } 199| 79.7k| if constexpr (std::same_as) { 200| 79.7k| func(params); 201| 79.7k| jsonrpc::write_response(state); 202| 79.7k| } 203| 79.7k| else { 204| 79.7k| auto ret = func(params); 205| 79.7k| jsonrpc::write_response(ret, state); 206| 79.7k| } 207| 79.7k| }; 208| 79.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| 3.58k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 3.58k| static thread_local std::decay_t params{}; 183| 3.58k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 3.58k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 593, False: 2.99k] ------------------ 185| 593| return; 186| 593| } 187| | 188| 2.99k| using Result = std::invoke_result_t; 189| | 190| 2.99k| if (state.notify()) { ------------------ | Branch (190:17): [True: 2.27k, False: 722] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 2.27k| else { 195| 2.27k| std::ignore = func(params); 196| 2.27k| } 197| 2.27k| return; 198| 2.27k| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 722| else { 204| 722| auto ret = func(params); 205| 722| jsonrpc::write_response(ret, state); 206| 722| } 207| 722| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 79.7k| { 181| 79.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 79.7k| static thread_local std::decay_t params{}; 183| 79.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 79.7k| if (!jsonrpc::read_params(params, state)) { 185| 79.7k| return; 186| 79.7k| } 187| | 188| 79.7k| using Result = std::invoke_result_t; 189| | 190| 79.7k| if (state.notify()) { 191| 79.7k| if constexpr (std::same_as) { 192| 79.7k| func(params); 193| 79.7k| } 194| 79.7k| else { 195| 79.7k| std::ignore = func(params); 196| 79.7k| } 197| 79.7k| return; 198| 79.7k| } 199| 79.7k| if constexpr (std::same_as) { 200| 79.7k| func(params); 201| 79.7k| jsonrpc::write_response(state); 202| 79.7k| } 203| 79.7k| else { 204| 79.7k| auto ret = func(params); 205| 79.7k| jsonrpc::write_response(ret, state); 206| 79.7k| } 207| 79.7k| }; 208| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFN12jsonrpc_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESP_: 181| 1.55k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 1.55k| static thread_local std::decay_t params{}; 183| 1.55k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 1.55k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 529, False: 1.03k] ------------------ 185| 529| return; 186| 529| } 187| | 188| 1.03k| using Result = std::invoke_result_t; 189| | 190| 1.03k| if (state.notify()) { ------------------ | Branch (190:17): [True: 893, False: 137] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 893| else { 195| 893| std::ignore = func(params); 196| 893| } 197| 893| return; 198| 893| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 137| else { 204| 137| auto ret = func(params); 205| 137| jsonrpc::write_response(ret, state); 206| 137| } 207| 137| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 180| 79.7k| { 181| 79.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 79.7k| static thread_local std::decay_t params{}; 183| 79.7k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 79.7k| if (!jsonrpc::read_params(params, state)) { 185| 79.7k| return; 186| 79.7k| } 187| | 188| 79.7k| using Result = std::invoke_result_t; 189| | 190| 79.7k| if (state.notify()) { 191| 79.7k| if constexpr (std::same_as) { 192| 79.7k| func(params); 193| 79.7k| } 194| 79.7k| else { 195| 79.7k| std::ignore = func(params); 196| 79.7k| } 197| 79.7k| return; 198| 79.7k| } 199| 79.7k| if constexpr (std::same_as) { 200| 79.7k| func(params); 201| 79.7k| jsonrpc::write_response(state); 202| 79.7k| } 203| 79.7k| else { 204| 79.7k| auto ret = func(params); 205| 79.7k| jsonrpc::write_response(ret, state); 206| 79.7k| } 207| 79.7k| }; 208| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESQ_: 181| 6.04k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 182| 6.04k| static thread_local std::decay_t params{}; 183| 6.04k| params = {}; // reset to avoid stale optional/variant fields across calls 184| 6.04k| if (!jsonrpc::read_params(params, state)) { ------------------ | Branch (184:17): [True: 1.77k, False: 4.26k] ------------------ 185| 1.77k| return; 186| 1.77k| } 187| | 188| 4.26k| using Result = std::invoke_result_t; 189| | 190| 4.26k| if (state.notify()) { ------------------ | Branch (190:17): [True: 2.41k, False: 1.85k] ------------------ 191| | if constexpr (std::same_as) { 192| | func(params); 193| | } 194| 2.41k| else { 195| 2.41k| std::ignore = func(params); 196| 2.41k| } 197| 2.41k| return; 198| 2.41k| } 199| | if constexpr (std::same_as) { 200| | func(params); 201| | jsonrpc::write_response(state); 202| | } 203| 1.85k| else { 204| 1.85k| auto ret = func(params); 205| 1.85k| jsonrpc::write_response(ret, state); 206| 1.85k| } 207| 1.85k| }; _ZN3glz7jsonrpc11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS3_9allocatorIdEEEETkNS0_8is_stateERNS0_5stateEEEbOT0_OT1_: 97| 6.04k| { 98| 6.04k| if (!state.has_body()) { ------------------ | Branch (98:14): [True: 2.41k, False: 3.62k] ------------------ 99| 2.41k| return true; // No params to read 100| 2.41k| } 101| | 102| 3.62k| auto ec = read(std::forward(value), state.params_json); 103| 3.62k| if (ec) { ------------------ | Branch (103:14): [True: 1.77k, False: 1.84k] ------------------ 104| 1.77k| write_error(state, rpc::error_e::invalid_params, "Invalid params", format_error(ec, state.params_json)); 105| 1.77k| return false; 106| 1.77k| } 107| 1.84k| return true; 108| 3.62k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 157| 79.7k| { 158| 79.7k| if constexpr (std::same_as) { 159| 79.7k| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 160| 79.7k| func(); 161| 79.7k| if (state.notify()) { 162| 79.7k| return; 163| 79.7k| } 164| 79.7k| jsonrpc::write_response(state); 165| 79.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| 79.7k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30200EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30200EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlONS_7jsonrpc5stateEE_clESL_: 159| 687| reg.endpoints[path] = [&func](jsonrpc::state&& state) mutable { 160| 687| func(); 161| 687| if (state.notify()) { ------------------ | Branch (161:20): [True: 407, False: 280] ------------------ 162| 407| return; 163| 407| } 164| 280| jsonrpc::write_response(state); 165| 280| }; jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 307| 79.7k| { 308| 79.7k| using impl = registry_impl; 309| | 310| 79.7k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 311| 79.7k| impl::register_endpoint(root, value, *this); 312| 79.7k| } 313| | 314| 79.7k| register_members(value); 315| 79.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 176| 79.7k| { 177| 79.7k| using namespace glz::detail; 178| 79.7k| static constexpr auto N = reflect::size; 179| | 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| 79.7k| } 184| 79.7k| else { 185| 79.7k| return nullptr; 186| 79.7k| } 187| 79.7k| }(); 188| | 189| 79.7k| using impl = registry_impl; 190| | 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| 79.7k| if constexpr (std::is_invocable_v) { 215| 79.7k| using Result = std::decay_t>; 216| 79.7k| impl::template register_function_endpoint(full_key, func, *this); 217| 79.7k| } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| 79.7k| } 227| 79.7k| else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| 79.7k| using Tuple = function_ptr_args_t>; 230| 79.7k| constexpr auto N = glz::tuple_size_v; 231| 79.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 236| 79.7k| } 237| 79.7k| else if constexpr (std::is_pointer_v> && 238| 79.7k| (glaze_object_t>> || 239| 79.7k| reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| 79.7k| if (func) { // Only traverse if pointer is valid 242| 79.7k| on>, full_key>(*func); 243| 79.7k| impl::template register_object_endpoint>>( 244| 79.7k| full_key, *func, *this); 245| 79.7k| } 246| | // else: skip registration for null pointers - no endpoints created 247| 79.7k| } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| 79.7k| } 253| 79.7k| else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| 79.7k| impl::template register_value_endpoint>(full_key, func, *this); 256| 79.7k| } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| 79.7k| if constexpr (std::is_void_v) { 266| 79.7k| if constexpr (n_args == 0) { 267| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 268| 79.7k| } 269| 79.7k| else if constexpr (n_args == 1) { 270| 79.7k| using Input = std::decay_t>; 271| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 272| 79.7k| func, *this); 273| 79.7k| } 274| 79.7k| else { 275| 79.7k| static_assert(false_v, "function cannot have more than one input"); 276| 79.7k| } 277| 79.7k| } 278| 79.7k| else { 279| | // Member function pointers 280| 79.7k| if constexpr (n_args == 0) { 281| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 282| 79.7k| } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| 79.7k| } 288| 79.7k| else { 289| 79.7k| static_assert(false_v, "function cannot have more than one input"); 290| 79.7k| } 291| 79.7k| } 292| 79.7k| } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); 300| 79.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| | if constexpr (reflectable && requires { to_tie(value); }) { 182| | return to_tie(value); 183| | } 184| 79.7k| else { 185| 79.7k| return nullptr; 186| 79.7k| } 187| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi0EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| | if constexpr (reflectable) { 194| | return get_member(value, get(t)); 195| | } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| 79.7k| else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| 79.7k| } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi1EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| | if constexpr (reflectable) { 194| | return get_member(value, get(t)); 195| | } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| 79.7k| if constexpr (std::is_void_v) { 266| 79.7k| if constexpr (n_args == 0) { 267| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi2EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| | if constexpr (reflectable) { 194| | return get_member(value, get(t)); 195| | } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| 79.7k| else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| 79.7k| } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILi3EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| | if constexpr (reflectable) { 194| | return get_member(value, get(t)); 195| | } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE2onIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 307| 79.7k| { 308| 79.7k| using impl = registry_impl; 309| | 310| 79.7k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 311| 79.7k| impl::register_endpoint(root, value, *this); 312| 79.7k| } 313| | 314| 79.7k| register_members(value); 315| 79.7k| } jsonrpc_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 176| 79.7k| { 177| 79.7k| using namespace glz::detail; 178| 79.7k| static constexpr auto N = reflect::size; 179| | 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| 79.7k| } 184| 79.7k| else { 185| 79.7k| return nullptr; 186| 79.7k| } 187| 79.7k| }(); 188| | 189| 79.7k| using impl = registry_impl; 190| | 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| 79.7k| if constexpr (std::is_invocable_v) { 215| 79.7k| using Result = std::decay_t>; 216| 79.7k| impl::template register_function_endpoint(full_key, func, *this); 217| 79.7k| } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| 79.7k| } 227| 79.7k| else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| 79.7k| using Tuple = function_ptr_args_t>; 230| 79.7k| constexpr auto N = glz::tuple_size_v; 231| 79.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 236| 79.7k| } 237| 79.7k| else if constexpr (std::is_pointer_v> && 238| 79.7k| (glaze_object_t>> || 239| 79.7k| reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| 79.7k| if (func) { // Only traverse if pointer is valid 242| 79.7k| on>, full_key>(*func); 243| 79.7k| impl::template register_object_endpoint>>( 244| 79.7k| full_key, *func, *this); 245| 79.7k| } 246| | // else: skip registration for null pointers - no endpoints created 247| 79.7k| } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| 79.7k| } 253| 79.7k| else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| 79.7k| impl::template register_value_endpoint>(full_key, func, *this); 256| 79.7k| } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| 79.7k| if constexpr (std::is_void_v) { 266| 79.7k| if constexpr (n_args == 0) { 267| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 268| 79.7k| } 269| 79.7k| else if constexpr (n_args == 1) { 270| 79.7k| using Input = std::decay_t>; 271| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 272| 79.7k| func, *this); 273| 79.7k| } 274| 79.7k| else { 275| 79.7k| static_assert(false_v, "function cannot have more than one input"); 276| 79.7k| } 277| 79.7k| } 278| 79.7k| else { 279| | // Member function pointers 280| 79.7k| if constexpr (n_args == 0) { 281| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 282| 79.7k| } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| 79.7k| } 288| 79.7k| else { 289| 79.7k| static_assert(false_v, "function cannot have more than one input"); 290| 79.7k| } 291| 79.7k| } 292| 79.7k| } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); 300| 79.7k| } jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| | } 184| | else { 185| | return nullptr; 186| | } 187| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.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_: 307| 79.7k| { 308| 79.7k| using impl = registry_impl; 309| | 310| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 311| | impl::register_endpoint(root, value, *this); 312| | } 313| | 314| 79.7k| register_members(value); 315| 79.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_: 176| 79.7k| { 177| 79.7k| using namespace glz::detail; 178| 79.7k| static constexpr auto N = reflect::size; 179| | 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| 79.7k| } 184| 79.7k| else { 185| 79.7k| return nullptr; 186| 79.7k| } 187| 79.7k| }(); 188| | 189| 79.7k| using impl = registry_impl; 190| | 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| 79.7k| if constexpr (std::is_invocable_v) { 215| 79.7k| using Result = std::decay_t>; 216| 79.7k| impl::template register_function_endpoint(full_key, func, *this); 217| 79.7k| } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| 79.7k| } 227| 79.7k| else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| 79.7k| using Tuple = function_ptr_args_t>; 230| 79.7k| constexpr auto N = glz::tuple_size_v; 231| 79.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 236| 79.7k| } 237| 79.7k| else if constexpr (std::is_pointer_v> && 238| 79.7k| (glaze_object_t>> || 239| 79.7k| reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| 79.7k| if (func) { // Only traverse if pointer is valid 242| 79.7k| on>, full_key>(*func); 243| 79.7k| impl::template register_object_endpoint>>( 244| 79.7k| full_key, *func, *this); 245| 79.7k| } 246| | // else: skip registration for null pointers - no endpoints created 247| 79.7k| } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| 79.7k| } 253| 79.7k| else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| 79.7k| impl::template register_value_endpoint>(full_key, func, *this); 256| 79.7k| } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| 79.7k| if constexpr (std::is_void_v) { 266| 79.7k| if constexpr (n_args == 0) { 267| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 268| 79.7k| } 269| 79.7k| else if constexpr (n_args == 1) { 270| 79.7k| using Input = std::decay_t>; 271| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 272| 79.7k| func, *this); 273| 79.7k| } 274| 79.7k| else { 275| 79.7k| static_assert(false_v, "function cannot have more than one input"); 276| 79.7k| } 277| 79.7k| } 278| 79.7k| else { 279| | // Member function pointers 280| 79.7k| if constexpr (n_args == 0) { 281| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 282| 79.7k| } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| 79.7k| } 288| 79.7k| else { 289| 79.7k| static_assert(false_v, "function cannot have more than one input"); 290| 79.7k| } 291| 79.7k| } 292| 79.7k| } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); 300| 79.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: 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| | } 184| | else { 185| | return nullptr; 186| | } 187| 79.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: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.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: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.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: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.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: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.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_: 307| 79.7k| { 308| 79.7k| using impl = registry_impl; 309| | 310| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 311| | impl::register_endpoint(root, value, *this); 312| | } 313| | 314| 79.7k| register_members(value); 315| 79.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_: 176| 79.7k| { 177| 79.7k| using namespace glz::detail; 178| 79.7k| static constexpr auto N = reflect::size; 179| | 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| 79.7k| } 184| 79.7k| else { 185| 79.7k| return nullptr; 186| 79.7k| } 187| 79.7k| }(); 188| | 189| 79.7k| using impl = registry_impl; 190| | 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| 79.7k| if constexpr (std::is_invocable_v) { 215| 79.7k| using Result = std::decay_t>; 216| 79.7k| impl::template register_function_endpoint(full_key, func, *this); 217| 79.7k| } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| 79.7k| } 227| 79.7k| else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| 79.7k| using Tuple = function_ptr_args_t>; 230| 79.7k| constexpr auto N = glz::tuple_size_v; 231| 79.7k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 236| 79.7k| } 237| 79.7k| else if constexpr (std::is_pointer_v> && 238| 79.7k| (glaze_object_t>> || 239| 79.7k| reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| 79.7k| if (func) { // Only traverse if pointer is valid 242| 79.7k| on>, full_key>(*func); 243| 79.7k| impl::template register_object_endpoint>>( 244| 79.7k| full_key, *func, *this); 245| 79.7k| } 246| | // else: skip registration for null pointers - no endpoints created 247| 79.7k| } 248| 79.7k| else if constexpr (glaze_object_t> || reflectable>) { 249| 79.7k| on, full_key>(func); 250| | 251| 79.7k| impl::template register_object_endpoint>(full_key, func, *this); 252| 79.7k| } 253| 79.7k| else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| 79.7k| impl::template register_value_endpoint>(full_key, func, *this); 256| 79.7k| } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| 79.7k| if constexpr (std::is_member_function_pointer_v>) { 261| 79.7k| using F = std::decay_t; 262| 79.7k| using Ret = typename return_type::type; 263| 79.7k| using Tuple = typename inputs_as_tuple::type; 264| 79.7k| constexpr auto n_args = glz::tuple_size_v; 265| 79.7k| if constexpr (std::is_void_v) { 266| 79.7k| if constexpr (n_args == 0) { 267| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 268| 79.7k| } 269| 79.7k| else if constexpr (n_args == 1) { 270| 79.7k| using Input = std::decay_t>; 271| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 272| 79.7k| func, *this); 273| 79.7k| } 274| 79.7k| else { 275| 79.7k| static_assert(false_v, "function cannot have more than one input"); 276| 79.7k| } 277| 79.7k| } 278| 79.7k| else { 279| | // Member function pointers 280| 79.7k| if constexpr (n_args == 0) { 281| 79.7k| impl::template register_member_function_endpoint(full_key, value, func, *this); 282| 79.7k| } 283| 79.7k| else if constexpr (n_args == 1) { 284| 79.7k| using Input = std::decay_t>; 285| 79.7k| impl::template register_member_function_with_params_endpoint(full_key, value, 286| 79.7k| func, *this); 287| 79.7k| } 288| 79.7k| else { 289| 79.7k| static_assert(false_v, "function cannot have more than one input"); 290| 79.7k| } 291| 79.7k| } 292| 79.7k| } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); 300| 79.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: 180| 79.7k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 181| 79.7k| if constexpr (reflectable && requires { to_tie(value); }) { 182| 79.7k| return to_tie(value); 183| | } 184| | else { 185| | return nullptr; 186| | } 187| 79.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: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.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: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.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: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.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: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| 79.7k| else { 258| 79.7k| static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| 79.7k| else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| 79.7k| impl::template register_variable_endpoint>(full_key, func, *this); 297| 79.7k| } 298| 79.7k| } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| | if constexpr (std::is_invocable_v) { 215| | using Result = std::decay_t>; 216| | impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| 79.7k| else if constexpr (is_invocable_concrete>) { 219| 79.7k| using Tuple = invocable_args_t>; 220| 79.7k| constexpr auto N = glz::tuple_size_v; 221| 79.7k| static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| 79.7k| using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| 79.7k| impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); jsonrpc_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDav: 191| 79.7k| for_each([&]() { 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| 79.7k| } 196| 79.7k| else { 197| 79.7k| return get_member(value, get(reflect::values)); 198| 79.7k| } 199| 79.7k| }(); 200| | 201| 79.7k| static constexpr auto key = reflect::keys[I]; 202| | 203| 79.7k| static constexpr std::string_view full_key = [&] { 204| 79.7k| if constexpr (parent == detail::empty_path) { 205| 79.7k| return join_v, key>; 206| 79.7k| } 207| 79.7k| else { 208| 79.7k| return join_v, key>; 209| 79.7k| } 210| 79.7k| }(); 211| | 212| | // This logic chain should match glz::cli_menu 213| 79.7k| using Func = decltype(func); 214| 79.7k| if constexpr (std::is_invocable_v) { 215| 79.7k| using Result = std::decay_t>; 216| 79.7k| impl::template register_function_endpoint(full_key, func, *this); 217| | } 218| | else if constexpr (is_invocable_concrete>) { 219| | using Tuple = invocable_args_t>; 220| | constexpr auto N = glz::tuple_size_v; 221| | static_assert(N == 1, "Only one input is allowed for your function"); 222| | 223| | using Params = glz::tuple_element_t<0, Tuple>; 224| | 225| | impl::template register_param_function_endpoint(full_key, func, *this); 226| | } 227| | else if constexpr (is_function_ptr_invocable>) { 228| | // Handle function pointers with arguments (e.g., void(*)(int)) 229| | using Tuple = function_ptr_args_t>; 230| | constexpr auto N = glz::tuple_size_v; 231| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 232| | 233| | using Params = glz::tuple_element_t<0, Tuple>; 234| | 235| | impl::template register_param_function_endpoint(full_key, func, *this); 236| | } 237| | else if constexpr (std::is_pointer_v> && 238| | (glaze_object_t>> || 239| | reflectable>>)) { 240| | // Handle pointer members explicitly for RPC traversal 241| | if (func) { // Only traverse if pointer is valid 242| | on>, full_key>(*func); 243| | impl::template register_object_endpoint>>( 244| | full_key, *func, *this); 245| | } 246| | // else: skip registration for null pointers - no endpoints created 247| | } 248| | else if constexpr (glaze_object_t> || reflectable>) { 249| | on, full_key>(func); 250| | 251| | impl::template register_object_endpoint>(full_key, func, *this); 252| | } 253| | else if constexpr (not std::is_lvalue_reference_v) { 254| | // For glz::custom, glz::manage, etc. 255| | impl::template register_value_endpoint>(full_key, func, *this); 256| | } 257| | else { 258| | static_assert(std::is_lvalue_reference_v); 259| | 260| | if constexpr (std::is_member_function_pointer_v>) { 261| | using F = std::decay_t; 262| | using Ret = typename return_type::type; 263| | using Tuple = typename inputs_as_tuple::type; 264| | constexpr auto n_args = glz::tuple_size_v; 265| | if constexpr (std::is_void_v) { 266| | if constexpr (n_args == 0) { 267| | impl::template register_member_function_endpoint(full_key, value, func, *this); 268| | } 269| | else if constexpr (n_args == 1) { 270| | using Input = std::decay_t>; 271| | impl::template register_member_function_with_params_endpoint(full_key, value, 272| | func, *this); 273| | } 274| | else { 275| | static_assert(false_v, "function cannot have more than one input"); 276| | } 277| | } 278| | else { 279| | // Member function pointers 280| | if constexpr (n_args == 0) { 281| | impl::template register_member_function_endpoint(full_key, value, func, *this); 282| | } 283| | else if constexpr (n_args == 1) { 284| | using Input = std::decay_t>; 285| | impl::template register_member_function_with_params_endpoint(full_key, value, 286| | func, *this); 287| | } 288| | else { 289| | static_assert(false_v, "function cannot have more than one input"); 290| | } 291| | } 292| | } 293| | else { 294| | // this is a variable and not a function, so we build RPC read/write calls 295| | // We can't remove const here, because const fields need to be able to be written 296| | impl::template register_variable_endpoint>(full_key, func, *this); 297| | } 298| | } 299| 79.7k| }); jsonrpc_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDavENKUlvE_clEv: 192| 79.7k| decltype(auto) func = [&]() -> decltype(auto) { 193| 79.7k| if constexpr (reflectable) { 194| 79.7k| return get_member(value, get(t)); 195| | } 196| | else { 197| | return get_member(value, get(reflect::values)); 198| | } 199| 79.7k| }(); _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE: 514| 79.7k| { 515| | // Find first non-whitespace to determine batch vs single request 516| 79.7k| auto it = std::find_if(json_request.begin(), json_request.end(), 517| 79.7k| [](char c) { return !std::isspace(static_cast(c)); }); 518| | 519| 79.7k| if (it != json_request.end() && *it == '[') { ------------------ | Branch (519:14): [True: 79.7k, False: 16] | Branch (519:42): [True: 30.5k, False: 49.2k] ------------------ 520| | // Batch request 521| 30.5k| std::vector batch_requests{}; 522| 30.5k| if (const auto ec = glz::read(batch_requests, json_request); ec) { ------------------ | Branch (522:85): [True: 9.92k, False: 20.6k] ------------------ 523| 9.92k| return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" + 524| 9.92k| write_json(format_error(ec, json_request)).value_or("null") + R"(},"id":null})"; 525| 9.92k| } 526| 20.6k| if (batch_requests.empty()) { ------------------ | Branch (526:17): [True: 21, False: 20.5k] ------------------ 527| 21| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":"Empty batch"},"id":null})"; 528| 21| } 529| 20.5k| return process_batch(batch_requests); 530| 20.6k| } 531| | 532| | // Single request 533| 49.2k| auto response = process_single_request(json_request); 534| 49.2k| return response.value_or(""); 535| 79.7k| } _ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE4callENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlcE_clEc: 517| 164k| [](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: 645| 20.5k| { 646| 20.5k| std::vector responses; 647| 20.5k| responses.reserve(batch.size()); 648| | 649| 20.5k| size_t total_size = 2; // [] 650| 4.27M| for (const auto& req : batch) { ------------------ | Branch (650:31): [True: 4.27M, False: 20.5k] ------------------ 651| 4.27M| auto response = process_single_request(req.str); 652| 4.27M| if (response.has_value()) { ------------------ | Branch (652:17): [True: 4.25M, False: 19.8k] ------------------ 653| 4.25M| total_size += response->size() + 1; // +1 for comma 654| | // Checked as the batch is walked rather than after it, so the elements past the 655| | // limit are never run and what they would have answered with is never built. The 656| | // element that trips it has already been built, so the peak is the limit plus one 657| | // response rather than the limit exactly. The elements already run keep their 658| | // effects -- a JSON RPC batch is not a transaction -- but the caller is told the 659| | // batch failed rather than handed a partial array it cannot distinguish from a 660| | // complete one. 661| 4.25M| if (total_size > max_batch_response_size) { ------------------ | Branch (661:20): [True: 6, False: 4.25M] ------------------ 662| 6| return R"({"jsonrpc":"2.0","error":{"code":-32000,"message":"Server error","data":"Batch response exceeds max_batch_response_size"},"id":null})"; 663| 6| } 664| 4.25M| responses.push_back(std::move(*response)); 665| 4.25M| } 666| 4.27M| } 667| | 668| | // If all were notifications, return empty string 669| 20.5k| if (responses.empty()) { ------------------ | Branch (669:14): [True: 216, False: 20.3k] ------------------ 670| 216| return ""; 671| 216| } 672| | 673| | // Build batch response array with pre-reserved capacity 674| 20.3k| std::string result; 675| 20.3k| result.reserve(total_size); 676| 20.3k| result = "["; 677| 3.34M| for (size_t i = 0; i < responses.size(); ++i) { ------------------ | Branch (677:29): [True: 3.32M, False: 20.3k] ------------------ 678| 3.32M| if (i > 0) { ------------------ | Branch (678:17): [True: 3.30M, False: 20.3k] ------------------ 679| 3.30M| result += ","; 680| 3.30M| } 681| 3.32M| result += responses[i]; 682| 3.32M| } 683| 20.3k| result += "]"; 684| 20.3k| return result; 685| 20.5k| } _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEE: 541| 4.32M| { 542| 4.32M| rpc::request_envelope_t request{}; 543| 4.32M| if (const auto read_ec = glz::read(request, json_request); read_ec) { ------------------ | Branch (543:80): [True: 4.25M, False: 62.5k] ------------------ 544| | // Check if it's a JSON syntax error vs schema error 545| 4.25M| static constexpr registry_validate_opts validate_opts{{read_opts}}; 546| 4.25M| glz::skip skip_value{}; 547| 4.25M| context validate_ctx{}; 548| 4.25M| if (glz::read(skip_value, json_request, validate_ctx)) { ------------------ | Branch (548:17): [True: 4.16M, False: 95.4k] ------------------ 549| | // JSON is syntactically invalid - return Parse error (-32700) 550| 4.16M| return R"({"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error","data":)" + 551| 4.16M| write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":null})"; 552| 4.16M| } 553| | // Valid JSON but invalid request structure - return Invalid Request (-32600) 554| 95.4k| auto id = glz::get_as_json(json_request); 555| 95.4k| std::string id_json = id.has_value() ? glz::write_json(id.value()).value_or("null") : "null"; ------------------ | Branch (555:35): [True: 6.08k, False: 89.3k] ------------------ 556| 95.4k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 557| 95.4k| write_json(format_error(read_ec, json_request)).value_or("null") + R"(},"id":)" + id_json + "}"; 558| 4.25M| } 559| | 560| 62.5k| auto& req = request; 561| | 562| 62.5k| const auto invalid_request = [&req](const std::string& data) { 563| 62.5k| std::string id_json = glz::write_json(req.id).value_or("null"); 564| 62.5k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 565| 62.5k| write_json(data).value_or("null") + R"(},"id":)" + id_json + "}"; 566| 62.5k| }; 567| | 568| | // `jsonrpc` and `method` are both required members, and an absent one cannot be allowed to 569| | // fall through to a default: an absent version would pass for 2.0, and an absent method 570| | // names "", which is the root endpoint -- so `{"id":1}` would answer with the whole 571| | // registered object rather than being rejected. 572| 62.5k| if (!req.version) { ------------------ | Branch (572:14): [True: 10.1k, False: 52.4k] ------------------ 573| 10.1k| return invalid_request("Missing 'jsonrpc' member"); 574| 10.1k| } 575| 52.4k| if (*req.version != rpc::supported_version) { ------------------ | Branch (575:14): [True: 3.91k, False: 48.5k] ------------------ 576| 3.91k| return invalid_request("Invalid version: " + std::string(*req.version)); 577| 3.91k| } 578| 48.5k| if (!req.method) { ------------------ | Branch (578:14): [True: 230, False: 48.2k] ------------------ 579| 230| return invalid_request("Missing 'method' member"); 580| 230| } 581| 48.2k| const std::string_view method_name = *req.method; 582| | 583| | // Check if this is a notification (id is null) 584| 48.2k| bool is_notification = std::holds_alternative(req.id); 585| | 586| | // Look up the endpoint - try direct lookup first (handles methods that already start with /) 587| 48.2k| auto it = endpoints.find(method_name); 588| 48.2k| if (it == endpoints.end()) { ------------------ | Branch (588:14): [True: 35.1k, False: 13.1k] ------------------ 589| 35.1k| if (!method_name.empty()) { ------------------ | Branch (589:17): [True: 35.1k, False: 0] ------------------ 590| | // Try with leading slash using stack buffer for common case 591| 35.1k| char buf[256]; 592| 35.1k| if (method_name.size() < sizeof(buf) - 1) { ------------------ | Branch (592:20): [True: 35.1k, False: 0] ------------------ 593| 35.1k| buf[0] = '/'; 594| 35.1k| std::memcpy(buf + 1, method_name.data(), method_name.size()); 595| 35.1k| it = endpoints.find(std::string_view{buf, method_name.size() + 1}); 596| 35.1k| } 597| 0| else { 598| | // Fallback for very long method names 599| 0| std::string method_path = "/"; 600| 0| method_path += method_name; 601| 0| it = endpoints.find(method_path); 602| 0| } 603| 35.1k| } 604| 0| else { 605| | // Empty method - try root endpoint 606| 0| it = endpoints.find(""); 607| 0| } 608| 35.1k| if (it == endpoints.end()) { ------------------ | Branch (608:17): [True: 183, False: 34.9k] ------------------ 609| 183| if (is_notification) { ------------------ | Branch (609:20): [True: 113, False: 70] ------------------ 610| 113| return std::nullopt; // No response for notifications 611| 113| } 612| 70| std::string id_json = glz::write_json(req.id).value_or("null"); 613| 70| return R"({"jsonrpc":"2.0","error":{"code":-32601,"message":"Method not found","data":)" + 614| 70| write_json(method_name).value_or("null") + R"(},"id":)" + id_json + "}"; 615| 183| } 616| 35.1k| } 617| | 618| | // Prepare state 619| 48.0k| std::string response; 620| 48.0k| bool has_params = !req.params.str.empty() && req.params.str != "null"; ------------------ | Branch (620:28): [True: 26.9k, False: 21.1k] | Branch (620:55): [True: 26.9k, False: 2] ------------------ 621| 48.0k| jsonrpc::state state{req.id, response, is_notification, has_params, req.params.str}; 622| | 623| 48.0k| try { 624| 48.0k| it->second(std::move(state)); 625| 48.0k| } 626| 48.0k| catch (const std::exception& e) { 627| 0| if (is_notification) { ------------------ | Branch (627:17): [True: 0, False: 0] ------------------ 628| 0| return std::nullopt; 629| 0| } 630| 0| std::string id_json = glz::write_json(req.id).value_or("null"); 631| 0| return R"({"jsonrpc":"2.0","error":{"code":-32603,"message":"Internal error","data":)" + 632| 0| write_json(std::string_view{e.what()}).value_or("null") + R"(},"id":)" + id_json + "}"; 633| 0| } 634| | 635| 48.0k| if (is_notification) { ------------------ | Branch (635:14): [True: 23.7k, False: 24.3k] ------------------ 636| 23.7k| return std::nullopt; 637| 23.7k| } 638| | 639| 24.3k| return response; 640| 48.0k| } _ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE22process_single_requestENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEQeqT0_L_ZNS_7JSONRPCEEENKUlRKNS3_12basic_stringIcS6_NS3_9allocatorIcEEEEE_clESD_: 562| 14.2k| const auto invalid_request = [&req](const std::string& data) { 563| 14.2k| std::string id_json = glz::write_json(req.id).value_or("null"); 564| 14.2k| return R"({"jsonrpc":"2.0","error":{"code":-32600,"message":"Invalid Request","data":)" + 565| 14.2k| write_json(data).value_or("null") + R"(},"id":)" + id_json + "}"; 566| 14.2k| }; _ZNK3glz6detail11string_hashclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 27| 1.91M| [[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_: 20| 45.1k| { 21| | // SSE2: 16 bytes at a time with direct comparison instructions 22| 45.1k| if (n > 15) { ------------------ | Branch (22:11): [True: 29.7k, False: 15.4k] ------------------ 23| 29.7k| const __m128i quote_vec = _mm_set1_epi8('"'); 24| 29.7k| const __m128i bs_vec = _mm_set1_epi8('\\'); 25| 29.7k| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 26| 29.7k| const __m128i zero = _mm_setzero_si128(); 27| | 28| 9.81M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (28:45): [True: 9.78M, False: 29.7k] ------------------ 29| 9.78M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 30| 9.78M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 31| | 32| 9.78M| const uint32_t mask = static_cast( 33| 9.78M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 34| 9.78M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 35| | 36| 9.78M| if (mask == 0) { ------------------ | Branch (36:17): [True: 62.0k, False: 9.72M] ------------------ 37| 62.0k| data += 16; 38| 62.0k| c += 16; 39| 62.0k| continue; 40| 62.0k| } 41| | 42| 9.72M| const uint32_t length = countr_zero(mask); 43| 9.72M| c += length; 44| 9.72M| data += length; 45| 9.72M| write_escape(); 46| 9.72M| } 47| 29.7k| } 48| 45.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_: 20| 5.88k| { 21| | // SSE2: 16 bytes at a time with direct comparison instructions 22| 5.88k| if (n > 15) { ------------------ | Branch (22:11): [True: 2.79k, False: 3.09k] ------------------ 23| 2.79k| const __m128i quote_vec = _mm_set1_epi8('"'); 24| 2.79k| const __m128i bs_vec = _mm_set1_epi8('\\'); 25| 2.79k| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 26| 2.79k| const __m128i zero = _mm_setzero_si128(); 27| | 28| 20.5M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (28:45): [True: 20.5M, False: 2.79k] ------------------ 29| 20.5M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 30| 20.5M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 31| | 32| 20.5M| const uint32_t mask = static_cast( 33| 20.5M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 34| 20.5M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 35| | 36| 20.5M| if (mask == 0) { ------------------ | Branch (36:17): [True: 888k, False: 19.7M] ------------------ 37| 888k| data += 16; 38| 888k| c += 16; 39| 888k| continue; 40| 888k| } 41| | 42| 19.7M| const uint32_t length = countr_zero(mask); 43| 19.7M| c += length; 44| 19.7M| data += length; 45| 19.7M| write_escape(); 46| 19.7M| } 47| 2.79k| } 48| 5.88k| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS9_SD_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 20| 1.02k| { 21| | // SSE2: 16 bytes at a time with direct comparison instructions 22| 1.02k| if (n > 15) { ------------------ | Branch (22:11): [True: 260, False: 763] ------------------ 23| 260| const __m128i quote_vec = _mm_set1_epi8('"'); 24| 260| const __m128i bs_vec = _mm_set1_epi8('\\'); 25| 260| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 26| 260| const __m128i zero = _mm_setzero_si128(); 27| | 28| 1.34M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (28:45): [True: 1.34M, False: 260] ------------------ 29| 1.34M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 30| 1.34M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 31| | 32| 1.34M| const uint32_t mask = static_cast( 33| 1.34M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 34| 1.34M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 35| | 36| 1.34M| if (mask == 0) { ------------------ | Branch (36:17): [True: 1.34M, False: 6.96k] ------------------ 37| 1.34M| data += 16; 38| 1.34M| c += 16; 39| 1.34M| continue; 40| 1.34M| } 41| | 42| 6.96k| const uint32_t length = countr_zero(mask); 43| 6.96k| c += length; 44| 6.96k| data += length; 45| 6.96k| write_escape(); 46| 6.96k| } 47| 260| } 48| 1.02k| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEERS9_S9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 20| 4.26M| { 21| | // SSE2: 16 bytes at a time with direct comparison instructions 22| 4.26M| if (n > 15) { ------------------ | Branch (22:11): [True: 4.26M, False: 0] ------------------ 23| 4.26M| const __m128i quote_vec = _mm_set1_epi8('"'); 24| 4.26M| const __m128i bs_vec = _mm_set1_epi8('\\'); 25| 4.26M| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 26| 4.26M| const __m128i zero = _mm_setzero_si128(); 27| | 28| 9.56M| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (28:45): [True: 5.29M, False: 4.26M] ------------------ 29| 5.29M| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 30| 5.29M| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 31| | 32| 5.29M| const uint32_t mask = static_cast( 33| 5.29M| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 34| 5.29M| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 35| | 36| 5.29M| if (mask == 0) { ------------------ | Branch (36:17): [True: 4.38M, False: 912k] ------------------ 37| 4.38M| data += 16; 38| 4.38M| c += 16; 39| 4.38M| continue; 40| 4.38M| } 41| | 42| 912k| const uint32_t length = countr_zero(mask); 43| 912k| c += length; 44| 912k| data += length; 45| 912k| write_escape(); 46| 912k| } 47| 4.26M| } 48| 4.26M| } _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_: 20| 70| { 21| | // SSE2: 16 bytes at a time with direct comparison instructions 22| 70| if (n > 15) { ------------------ | Branch (22:11): [True: 0, False: 70] ------------------ 23| 0| const __m128i quote_vec = _mm_set1_epi8('"'); 24| 0| const __m128i bs_vec = _mm_set1_epi8('\\'); 25| 0| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 26| 0| const __m128i zero = _mm_setzero_si128(); 27| | 28| 0| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (28:45): [True: 0, False: 0] ------------------ 29| 0| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 30| 0| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 31| | 32| 0| const uint32_t mask = static_cast( 33| 0| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 34| 0| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 35| | 36| 0| if (mask == 0) { ------------------ | Branch (36:17): [True: 0, False: 0] ------------------ 37| 0| data += 16; 38| 0| c += 16; 39| 0| continue; 40| 0| } 41| | 42| 0| const uint32_t length = countr_zero(mask); 43| 0| c += length; 44| 0| data += length; 45| 0| write_escape(); 46| 0| } 47| 0| } 48| 70| } _ZN3glz6detail10structural11load_windowEPKccc: 87| 2.85M| { 88| 2.85M| const __m128i v0 = _mm_loadu_si128(reinterpret_cast(p)); 89| 2.85M| const __m128i v1 = _mm_loadu_si128(reinterpret_cast(p + 16)); 90| 2.85M| const __m128i v2 = _mm_loadu_si128(reinterpret_cast(p + 32)); 91| 2.85M| const __m128i v3 = _mm_loadu_si128(reinterpret_cast(p + 48)); 92| | 93| 2.85M| const auto mask_of = [&](const char c) { 94| 2.85M| const __m128i cv = _mm_set1_epi8(c); 95| 2.85M| return uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v0, cv)))) | 96| 2.85M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v1, cv)))) << 16) | 97| 2.85M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v2, cv)))) << 32) | 98| 2.85M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v3, cv)))) << 48); 99| 2.85M| }; 100| | 101| 2.85M| const uint64_t high = 102| 2.85M| uint64_t(uint16_t(_mm_movemask_epi8(v0))) | (uint64_t(uint16_t(_mm_movemask_epi8(v1))) << 16) | 103| 2.85M| (uint64_t(uint16_t(_mm_movemask_epi8(v2))) << 32) | (uint64_t(uint16_t(_mm_movemask_epi8(v3))) << 48); 104| | 105| 2.85M| return {mask_of('"'), mask_of('\\'), mask_of(open_c), mask_of(close_c), high}; 106| 2.85M| } _ZZN3glz6detail10structural11load_windowEPKcccENKUlcE_clEc: 93| 11.4M| const auto mask_of = [&](const char c) { 94| 11.4M| const __m128i cv = _mm_set1_epi8(c); 95| 11.4M| return uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v0, cv)))) | 96| 11.4M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v1, cv)))) << 16) | 97| 11.4M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v2, cv)))) << 32) | 98| 11.4M| (uint64_t(uint16_t(_mm_movemask_epi8(_mm_cmpeq_epi8(v3, cv)))) << 48); 99| 11.4M| }; _ZN3glz4atoiITkNSt3__18integralEicEEbRT_RPKT0_S6_: 806| 450k| { 807| | // The number of characters needed at most for each type, rounded to nearest 8 bytes 808| 450k| constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1]; 809| | // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The 810| | // trailing byte is never written by the copy, so the null-terminated atoi below always halts 811| | // inside the array even when the input fills it: the exponent scan stops at a non-digit rather 812| | // than after a fixed digit count, and a value-initialized array alone would not terminate a 813| | // copy that covers every byte. 814| 450k| std::array data{}; 815| 450k| const auto n = size_t(end - it); 816| 450k| if (n > 0) [[likely]] { ------------------ | Branch (816:11): [True: 450k, False: 0] ------------------ 817| 450k| const auto truncated = n > buffer_length; 818| 450k| std::memcpy(data.data(), it, truncated ? buffer_length : n); ------------------ | Branch (818:39): [True: 431k, False: 18.1k] ------------------ 819| | 820| 450k| const auto start = data.data(); 821| 450k| const auto* c = start; 822| 450k| const auto valid = glz::atoi(v, c); 823| 450k| const auto consumed = size_t(c - start); 824| 450k| it += consumed; 825| | // Reaching the end of a truncated copy means the number was cut off: parsing halted on the 826| | // terminator this buffer supplies rather than on a character of the input, so what parsed is 827| | // a prefix and its value is not the number's. Only zero padding can stretch a number this 828| | // far -- no in-range integer needs buffer_length characters -- but a caller that ignores 829| | // trailing content would otherwise take the prefix's value as the answer. 830| 450k| return valid && not(truncated && consumed == buffer_length); ------------------ | Branch (830:17): [True: 444k, False: 5.10k] | Branch (830:30): [True: 431k, False: 13.4k] | Branch (830:43): [True: 7, False: 431k] ------------------ 831| 450k| } 832| 0| else [[unlikely]] { 833| 0| return false; 834| 0| } 835| 450k| } _ZN3glz4atoiITkNSt3__18integralEiKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_: 718| 450k| { 719| 450k| using X = std::decay_t; 720| 450k| using utype = std::make_unsigned_t; 721| | 722| 450k| const uint8_t sign = *c == '-'; 723| 450k| if (auto ptr = parse_int(v, reinterpret_cast(c))) [[likely]] { ------------------ | Branch (723:16): [True: 446k, False: 3.24k] ------------------ 724| 446k| c = reinterpret_cast(ptr); 725| 446k| if (*c == 'e' || *c == 'E') { ------------------ | Branch (725:14): [True: 12.3k, False: 434k] | Branch (725:27): [True: 25.3k, False: 409k] ------------------ 726| 37.7k| ++c; 727| 37.7k| } 728| 409k| else { 729| 409k| if (*c == '.') [[unlikely]] { ------------------ | Branch (729:17): [True: 50, False: 409k] ------------------ 730| 50| return false; 731| 50| } 732| 409k| return true; 733| 409k| } 734| | 735| 37.7k| c += (*c == '+'); 736| | 737| 37.7k| if (not is_digit(*c)) [[unlikely]] { ------------------ | Branch (737:14): [True: 297, False: 37.4k] ------------------ 738| 297| return false; 739| 297| } 740| 37.4k| const uint32_t exp = parse_exponent(c); 741| | // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and 742| | // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative 743| | // zero compares equal to zero, so both spellings land here with the value they should keep. 744| | if constexpr (sizeof(T) == 1) { 745| | if (exp > 2) [[unlikely]] { 746| | return v == 0; 747| | } 748| | } 749| | else if constexpr (sizeof(T) == 2) { 750| | if (exp > 4) [[unlikely]] { 751| | return v == 0; 752| | } 753| | } 754| 37.4k| else if constexpr (sizeof(T) == 4) { 755| 37.4k| if (exp > 9) [[unlikely]] { ------------------ | Branch (755:17): [True: 3.58k, False: 33.8k] ------------------ 756| 3.58k| return v == 0; 757| 3.58k| } 758| | } 759| | else { 760| | if (exp > 18) [[unlikely]] { 761| | return v == 0; 762| | } 763| | } 764| | 765| 33.8k| utype i = utype((utype(v) ^ -sign) + sign); 766| 37.4k| if constexpr (sizeof(T) < 8) { 767| | // Scale in a width the product cannot wrap, then range check before narrowing. Scaling 768| | // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude 769| | // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for 770| | // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well 771| | // inside uint64_t. The unsigned path already widens the same way. 772| 37.4k| const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp]; 773| 37.4k| v = T((utype(scaled) ^ -sign) + sign); 774| | // Bound the magnitude directly rather than subtracting the sign from it: a negative 775| | // zero makes `scaled - sign` underflow, and the old narrow expression only survived 776| | // that because it promoted to int. A negative value may reach one past the positive 777| | // limit, which is exactly INT_MIN's magnitude. 778| 37.4k| return scaled <= uint64_t((std::numeric_limits::max)()) + sign; 779| | } 780| | else { 781| | // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`: 782| | // for a negative value that pattern is a huge unsigned number, so every negative 783| | // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The 784| | // narrower branches above already scale `i`. 785| |#if defined(__SIZEOF_INT128__) 786| | const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp]; 787| | v = T((uint64_t(res) ^ -sign) + sign); 788| | // Compare the full 128-bit product. Narrowing it to 64 bits first would let an 789| | // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range. 790| | return res <= __uint128_t(9223372036854775807ull + sign); 791| |#else 792| | const auto res = full_multiplication(i, powers_of_ten_int[exp]); 793| | v = T((uint64_t(res.low) ^ -sign) + sign); 794| | return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign)); 795| |#endif 796| | } 797| 37.4k| } 798| 40.6k| return false; 799| 450k| } _ZN3glz9parse_intITkNSt3__18integralEiQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_: 479| 450k| { 480| 450k| const uint8_t sign = *c == '-'; 481| 450k| c += sign; 482| | 483| 450k| if (is_digit(*c)) [[likely]] { ------------------ | Branch (483:11): [True: 447k, False: 2.71k] ------------------ 484| 447k| v = *c - '0'; 485| 447k| ++c; 486| 447k| } 487| 2.71k| else [[unlikely]] { 488| 2.71k| return {}; 489| 2.71k| } 490| | 491| 447k| if (is_digit(*c)) { ------------------ | Branch (491:11): [True: 333k, False: 113k] ------------------ 492| 333k| v = v * 10 + (*c - '0'); 493| 333k| ++c; 494| 333k| } 495| 113k| else { 496| 113k| if (sign) { ------------------ | Branch (496:14): [True: 51.0k, False: 62.6k] ------------------ 497| 51.0k| v = -v; 498| 51.0k| } 499| 113k| return c; 500| 113k| } 501| | 502| 333k| if (c[-2] == '0') [[unlikely]] { ------------------ | Branch (502:11): [True: 69, False: 333k] ------------------ 503| 69| return {}; 504| 69| } 505| | 506| 333k| if constexpr (sizeof(T) > 1) { 507| 333k| if (is_digit(*c)) { ------------------ | Branch (507:14): [True: 190k, False: 143k] ------------------ 508| 190k| v = v * 10 + (*c - '0'); 509| 190k| ++c; 510| 190k| } 511| 143k| else { 512| 143k| if (sign) { ------------------ | Branch (512:17): [True: 97.8k, False: 45.5k] ------------------ 513| 97.8k| v = -v; 514| 97.8k| } 515| 143k| return c; 516| 143k| } 517| | 518| 190k| if (is_digit(*c)) { ------------------ | Branch (518:14): [True: 113k, False: 76.6k] ------------------ 519| 113k| v = v * 10 + (*c - '0'); 520| 113k| ++c; 521| 113k| } 522| 76.6k| else { 523| 76.6k| if (sign) { ------------------ | Branch (523:17): [True: 57.3k, False: 19.3k] ------------------ 524| 57.3k| v = -v; 525| 57.3k| } 526| 76.6k| return c; 527| 76.6k| } 528| | 529| 113k| if constexpr (sizeof(T) > 2) { 530| 113k| if (is_digit(*c)) { ------------------ | Branch (530:17): [True: 78.4k, False: 35.0k] ------------------ 531| 78.4k| v = v * 10 + (*c - '0'); 532| 78.4k| ++c; 533| 78.4k| } 534| 35.0k| else { 535| 35.0k| if (sign) { ------------------ | Branch (535:20): [True: 5.29k, False: 29.7k] ------------------ 536| 5.29k| v = -v; 537| 5.29k| } 538| 35.0k| return c; 539| 35.0k| } 540| | 541| 78.4k| if (is_digit(*c)) { ------------------ | Branch (541:17): [True: 65.5k, False: 12.9k] ------------------ 542| 65.5k| v = v * 10 + (*c - '0'); 543| 65.5k| ++c; 544| 65.5k| } 545| 12.9k| else { 546| 12.9k| if (sign) { ------------------ | Branch (546:20): [True: 4.44k, False: 8.49k] ------------------ 547| 4.44k| v = -v; 548| 4.44k| } 549| 12.9k| return c; 550| 12.9k| } 551| | 552| 65.5k| if (is_digit(*c)) { ------------------ | Branch (552:17): [True: 44.1k, False: 21.3k] ------------------ 553| 44.1k| v = v * 10 + (*c - '0'); 554| 44.1k| ++c; 555| 44.1k| } 556| 21.3k| else { 557| 21.3k| if (sign) { ------------------ | Branch (557:20): [True: 5.40k, False: 15.9k] ------------------ 558| 5.40k| v = -v; 559| 5.40k| } 560| 21.3k| return c; 561| 21.3k| } 562| | 563| 44.1k| if (is_digit(*c)) { ------------------ | Branch (563:17): [True: 30.7k, False: 13.3k] ------------------ 564| 30.7k| v = v * 10 + (*c - '0'); 565| 30.7k| ++c; 566| 30.7k| } 567| 13.3k| else { 568| 13.3k| if (sign) { ------------------ | Branch (568:20): [True: 3.05k, False: 10.3k] ------------------ 569| 3.05k| v = -v; 570| 3.05k| } 571| 13.3k| return c; 572| 13.3k| } 573| | 574| 30.7k| if (is_digit(*c)) { ------------------ | Branch (574:17): [True: 17.4k, False: 13.3k] ------------------ 575| 17.4k| v = v * 10 + (*c - '0'); 576| 17.4k| ++c; 577| 17.4k| } 578| 13.3k| else { 579| 13.3k| if (sign) { ------------------ | Branch (579:20): [True: 5.08k, False: 8.23k] ------------------ 580| 5.08k| v = -v; 581| 5.08k| } 582| 13.3k| return c; 583| 13.3k| } 584| | 585| | if constexpr (sizeof(T) > 4) { 586| | if (is_digit(*c)) { 587| | v = v * 10 + (*c - '0'); 588| | ++c; 589| | } 590| | else { 591| | if (sign) { 592| | v = -v; 593| | } 594| | return c; 595| | } 596| | 597| | if (is_digit(*c)) { 598| | v = v * 10 + (*c - '0'); 599| | ++c; 600| | } 601| | else { 602| | if (sign) { 603| | v = -v; 604| | } 605| | return c; 606| | } 607| | 608| | if (is_digit(*c)) { 609| | v = v * 10 + (*c - '0'); 610| | ++c; 611| | } 612| | else { 613| | if (sign) { 614| | v = -v; 615| | } 616| | return c; 617| | } 618| | 619| | if (is_digit(*c)) { 620| | v = v * 10 + (*c - '0'); 621| | ++c; 622| | } 623| | else { 624| | if (sign) { 625| | v = -v; 626| | } 627| | return c; 628| | } 629| | 630| | if (is_digit(*c)) { 631| | v = v * 10 + (*c - '0'); 632| | ++c; 633| | } 634| | else { 635| | if (sign) { 636| | v = -v; 637| | } 638| | return c; 639| | } 640| | 641| | if (is_digit(*c)) { 642| | v = v * 10 + (*c - '0'); 643| | ++c; 644| | } 645| | else { 646| | if (sign) { 647| | v = -v; 648| | } 649| | return c; 650| | } 651| | 652| | if (is_digit(*c)) { 653| | v = v * 10 + (*c - '0'); 654| | ++c; 655| | } 656| | else { 657| | if (sign) { 658| | v = -v; 659| | } 660| | return c; 661| | } 662| | 663| | if (is_digit(*c)) { 664| | v = v * 10 + (*c - '0'); 665| | ++c; 666| | } 667| | else { 668| | if (sign) { 669| | v = -v; 670| | } 671| | return c; 672| | } 673| | 674| | if (is_digit(*c)) { 675| | v = v * 10 + (*c - '0'); 676| | ++c; 677| | } 678| | else { 679| | if (sign) { 680| | v = -v; 681| | } 682| | return c; 683| | } 684| | } 685| 17.4k| } 686| 113k| } 687| | 688| 333k| if (is_digit(*c)) { ------------------ | Branch (688:11): [True: 6.33k, False: 327k] ------------------ 689| 6.33k| if (sign) { ------------------ | Branch (689:14): [True: 2.93k, False: 3.39k] ------------------ 690| 2.93k| if (would_overflow_negative(v, *c)) [[unlikely]] { ------------------ | Branch (690:17): [True: 206, False: 2.73k] ------------------ 691| 206| return {}; 692| 206| } 693| 2.73k| v = -1 * v; 694| 2.73k| v = v * 10 - (*c - '0'); 695| 2.73k| } 696| 3.39k| else { 697| 3.39k| if (would_overflow_positive(v, *c)) [[unlikely]] { ------------------ | Branch (697:17): [True: 136, False: 3.25k] ------------------ 698| 136| return {}; 699| 136| } 700| 3.25k| v = v * 10 + (*c - '0'); 701| 3.25k| } 702| 5.98k| ++c; 703| 5.98k| if (is_digit(*c)) [[unlikely]] { ------------------ | Branch (703:14): [True: 120, False: 5.86k] ------------------ 704| 120| return {}; 705| 120| } 706| 5.86k| return c; 707| 5.98k| } 708| | 709| 327k| if (sign) { ------------------ | Branch (709:11): [True: 3.94k, False: 323k] ------------------ 710| 3.94k| v = -v; 711| 3.94k| } 712| 327k| return c; 713| 333k| } _ZN3glz23would_overflow_negativeIiEEbu17__remove_volatileIT_Eh: 154| 2.93k| { 155| | // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32) 156| 2.93k| using U = std::remove_volatile_t; 157| 2.93k| constexpr auto max_val = static_cast((std::numeric_limits::max)()) + 1; 158| 2.93k| constexpr auto threshold = max_val / 10; 159| 2.93k| constexpr auto last_digit = max_val % 10; 160| 2.93k| const auto uv = static_cast(v); 161| 2.93k| const auto digit = static_cast(next_digit - '0'); 162| | // When digit > last_digit, effective threshold is one less 163| 2.93k| return uv > (threshold - uint64_t(digit > last_digit)); 164| 2.93k| } _ZN3glz23would_overflow_positiveIiEEbu17__remove_volatileIT_Eh: 140| 3.39k| { 141| 3.39k| using U = std::remove_volatile_t; 142| 3.39k| constexpr auto max_val = static_cast((std::numeric_limits::max)()); 143| 3.39k| constexpr auto threshold = max_val / 10; 144| 3.39k| constexpr auto last_digit = max_val % 10; 145| 3.39k| const auto uv = static_cast(v); 146| 3.39k| const auto digit = static_cast(next_digit - '0'); 147| | // When digit > last_digit, effective threshold is one less 148| | // This is branch-free and faster than bitwise OR/AND approach 149| 3.39k| return uv > (threshold - uint64_t(digit > last_digit)); 150| 3.39k| } _ZN3glz8is_digitEh: 106| 17.5M| GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; } ------------------ | Branch (106:81): [True: 17.1M, False: 405k] | Branch (106:93): [True: 11.6M, False: 5.52M] ------------------ _ZN3glz14parse_exponentIKcEEjRPT_: 124| 44.4k| { 125| 44.4k| uint32_t exp = uint32_t(*c - '0'); 126| 44.4k| ++c; 127| 94.2k| while (is_digit(*c)) { ------------------ | Branch (127:14): [True: 49.7k, False: 44.4k] ------------------ 128| | // Written as a select rather than a branch: the clamp only ever engages on absurdly long 129| | // exponents, so a branch here would be a mispredict risk on the path that matters. 130| 49.7k| exp = exp < exponent_clamp ? exp * 10 + uint32_t(*c - '0') : exp; ------------------ | Branch (130:16): [True: 43.8k, False: 5.88k] ------------------ 131| 49.7k| ++c; 132| 49.7k| } 133| 44.4k| return exp; 134| 44.4k| } _ZN3glz4atoiITkNSt3__18integralElcEEbRT_RPKT0_S6_: 806| 76.4k| { 807| | // The number of characters needed at most for each type, rounded to nearest 8 bytes 808| 76.4k| constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1]; 809| | // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The 810| | // trailing byte is never written by the copy, so the null-terminated atoi below always halts 811| | // inside the array even when the input fills it: the exponent scan stops at a non-digit rather 812| | // than after a fixed digit count, and a value-initialized array alone would not terminate a 813| | // copy that covers every byte. 814| 76.4k| std::array data{}; 815| 76.4k| const auto n = size_t(end - it); 816| 76.4k| if (n > 0) [[likely]] { ------------------ | Branch (816:11): [True: 76.4k, False: 0] ------------------ 817| 76.4k| const auto truncated = n > buffer_length; 818| 76.4k| std::memcpy(data.data(), it, truncated ? buffer_length : n); ------------------ | Branch (818:39): [True: 22.5k, False: 53.8k] ------------------ 819| | 820| 76.4k| const auto start = data.data(); 821| 76.4k| const auto* c = start; 822| 76.4k| const auto valid = glz::atoi(v, c); 823| 76.4k| const auto consumed = size_t(c - start); 824| 76.4k| it += consumed; 825| | // Reaching the end of a truncated copy means the number was cut off: parsing halted on the 826| | // terminator this buffer supplies rather than on a character of the input, so what parsed is 827| | // a prefix and its value is not the number's. Only zero padding can stretch a number this 828| | // far -- no in-range integer needs buffer_length characters -- but a caller that ignores 829| | // trailing content would otherwise take the prefix's value as the answer. 830| 76.4k| return valid && not(truncated && consumed == buffer_length); ------------------ | Branch (830:17): [True: 59.2k, False: 17.1k] | Branch (830:30): [True: 21.7k, False: 37.5k] | Branch (830:43): [True: 26, False: 21.7k] ------------------ 831| 76.4k| } 832| 0| else [[unlikely]] { 833| 0| return false; 834| 0| } 835| 76.4k| } _ZN3glz4atoiITkNSt3__18integralElKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_: 718| 76.4k| { 719| 76.4k| using X = std::decay_t; 720| 76.4k| using utype = std::make_unsigned_t; 721| | 722| 76.4k| const uint8_t sign = *c == '-'; 723| 76.4k| if (auto ptr = parse_int(v, reinterpret_cast(c))) [[likely]] { ------------------ | Branch (723:16): [True: 66.8k, False: 9.56k] ------------------ 724| 66.8k| c = reinterpret_cast(ptr); 725| 66.8k| if (*c == 'e' || *c == 'E') { ------------------ | Branch (725:14): [True: 2.51k, False: 64.3k] | Branch (725:27): [True: 5.57k, False: 58.7k] ------------------ 726| 8.09k| ++c; 727| 8.09k| } 728| 58.7k| else { 729| 58.7k| if (*c == '.') [[unlikely]] { ------------------ | Branch (729:17): [True: 2.25k, False: 56.5k] ------------------ 730| 2.25k| return false; 731| 2.25k| } 732| 56.5k| return true; 733| 58.7k| } 734| | 735| 8.09k| c += (*c == '+'); 736| | 737| 8.09k| if (not is_digit(*c)) [[unlikely]] { ------------------ | Branch (737:14): [True: 1.02k, False: 7.06k] ------------------ 738| 1.02k| return false; 739| 1.02k| } 740| 7.06k| const uint32_t exp = parse_exponent(c); 741| | // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and 742| | // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative 743| | // zero compares equal to zero, so both spellings land here with the value they should keep. 744| | if constexpr (sizeof(T) == 1) { 745| | if (exp > 2) [[unlikely]] { 746| | return v == 0; 747| | } 748| | } 749| | else if constexpr (sizeof(T) == 2) { 750| | if (exp > 4) [[unlikely]] { 751| | return v == 0; 752| | } 753| | } 754| | else if constexpr (sizeof(T) == 4) { 755| | if (exp > 9) [[unlikely]] { 756| | return v == 0; 757| | } 758| | } 759| 7.06k| else { 760| 7.06k| if (exp > 18) [[unlikely]] { ------------------ | Branch (760:17): [True: 3.66k, False: 3.39k] ------------------ 761| 3.66k| return v == 0; 762| 3.66k| } 763| 7.06k| } 764| | 765| 3.39k| utype i = utype((utype(v) ^ -sign) + sign); 766| | if constexpr (sizeof(T) < 8) { 767| | // Scale in a width the product cannot wrap, then range check before narrowing. Scaling 768| | // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude 769| | // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for 770| | // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well 771| | // inside uint64_t. The unsigned path already widens the same way. 772| | const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp]; 773| | v = T((utype(scaled) ^ -sign) + sign); 774| | // Bound the magnitude directly rather than subtracting the sign from it: a negative 775| | // zero makes `scaled - sign` underflow, and the old narrow expression only survived 776| | // that because it promoted to int. A negative value may reach one past the positive 777| | // limit, which is exactly INT_MIN's magnitude. 778| | return scaled <= uint64_t((std::numeric_limits::max)()) + sign; 779| | } 780| 7.06k| else { 781| | // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`: 782| | // for a negative value that pattern is a huge unsigned number, so every negative 783| | // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The 784| | // narrower branches above already scale `i`. 785| 7.06k|#if defined(__SIZEOF_INT128__) 786| 7.06k| const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp]; 787| 7.06k| v = T((uint64_t(res) ^ -sign) + sign); 788| | // Compare the full 128-bit product. Narrowing it to 64 bits first would let an 789| | // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range. 790| 7.06k| return res <= __uint128_t(9223372036854775807ull + sign); 791| |#else 792| | const auto res = full_multiplication(i, powers_of_ten_int[exp]); 793| | v = T((uint64_t(res.low) ^ -sign) + sign); 794| | return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign)); 795| |#endif 796| 7.06k| } 797| 7.06k| } 798| 16.6k| return false; 799| 76.4k| } _ZN3glz9parse_intITkNSt3__18integralElQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_: 479| 76.4k| { 480| 76.4k| const uint8_t sign = *c == '-'; 481| 76.4k| c += sign; 482| | 483| 76.4k| if (is_digit(*c)) [[likely]] { ------------------ | Branch (483:11): [True: 75.3k, False: 1.05k] ------------------ 484| 75.3k| v = *c - '0'; 485| 75.3k| ++c; 486| 75.3k| } 487| 1.05k| else [[unlikely]] { 488| 1.05k| return {}; 489| 1.05k| } 490| | 491| 75.3k| if (is_digit(*c)) { ------------------ | Branch (491:11): [True: 41.7k, False: 33.6k] ------------------ 492| 41.7k| v = v * 10 + (*c - '0'); 493| 41.7k| ++c; 494| 41.7k| } 495| 33.6k| else { 496| 33.6k| if (sign) { ------------------ | Branch (496:14): [True: 1.32k, False: 32.3k] ------------------ 497| 1.32k| v = -v; 498| 1.32k| } 499| 33.6k| return c; 500| 33.6k| } 501| | 502| 41.7k| if (c[-2] == '0') [[unlikely]] { ------------------ | Branch (502:11): [True: 308, False: 41.4k] ------------------ 503| 308| return {}; 504| 308| } 505| | 506| 41.4k| if constexpr (sizeof(T) > 1) { 507| 41.4k| if (is_digit(*c)) { ------------------ | Branch (507:14): [True: 39.8k, False: 1.59k] ------------------ 508| 39.8k| v = v * 10 + (*c - '0'); 509| 39.8k| ++c; 510| 39.8k| } 511| 1.59k| else { 512| 1.59k| if (sign) { ------------------ | Branch (512:17): [True: 568, False: 1.02k] ------------------ 513| 568| v = -v; 514| 568| } 515| 1.59k| return c; 516| 1.59k| } 517| | 518| 39.8k| if (is_digit(*c)) { ------------------ | Branch (518:14): [True: 37.6k, False: 2.16k] ------------------ 519| 37.6k| v = v * 10 + (*c - '0'); 520| 37.6k| ++c; 521| 37.6k| } 522| 2.16k| else { 523| 2.16k| if (sign) { ------------------ | Branch (523:17): [True: 875, False: 1.29k] ------------------ 524| 875| v = -v; 525| 875| } 526| 2.16k| return c; 527| 2.16k| } 528| | 529| 37.6k| if constexpr (sizeof(T) > 2) { 530| 37.6k| if (is_digit(*c)) { ------------------ | Branch (530:17): [True: 35.6k, False: 1.98k] ------------------ 531| 35.6k| v = v * 10 + (*c - '0'); 532| 35.6k| ++c; 533| 35.6k| } 534| 1.98k| else { 535| 1.98k| if (sign) { ------------------ | Branch (535:20): [True: 1.00k, False: 977] ------------------ 536| 1.00k| v = -v; 537| 1.00k| } 538| 1.98k| return c; 539| 1.98k| } 540| | 541| 35.6k| if (is_digit(*c)) { ------------------ | Branch (541:17): [True: 31.6k, False: 3.99k] ------------------ 542| 31.6k| v = v * 10 + (*c - '0'); 543| 31.6k| ++c; 544| 31.6k| } 545| 3.99k| else { 546| 3.99k| if (sign) { ------------------ | Branch (546:20): [True: 2.92k, False: 1.06k] ------------------ 547| 2.92k| v = -v; 548| 2.92k| } 549| 3.99k| return c; 550| 3.99k| } 551| | 552| 31.6k| if (is_digit(*c)) { ------------------ | Branch (552:17): [True: 29.8k, False: 1.78k] ------------------ 553| 29.8k| v = v * 10 + (*c - '0'); 554| 29.8k| ++c; 555| 29.8k| } 556| 1.78k| else { 557| 1.78k| if (sign) { ------------------ | Branch (557:20): [True: 847, False: 940] ------------------ 558| 847| v = -v; 559| 847| } 560| 1.78k| return c; 561| 1.78k| } 562| | 563| 29.8k| if (is_digit(*c)) { ------------------ | Branch (563:17): [True: 28.4k, False: 1.46k] ------------------ 564| 28.4k| v = v * 10 + (*c - '0'); 565| 28.4k| ++c; 566| 28.4k| } 567| 1.46k| else { 568| 1.46k| if (sign) { ------------------ | Branch (568:20): [True: 691, False: 772] ------------------ 569| 691| v = -v; 570| 691| } 571| 1.46k| return c; 572| 1.46k| } 573| | 574| 28.4k| if (is_digit(*c)) { ------------------ | Branch (574:17): [True: 26.6k, False: 1.78k] ------------------ 575| 26.6k| v = v * 10 + (*c - '0'); 576| 26.6k| ++c; 577| 26.6k| } 578| 1.78k| else { 579| 1.78k| if (sign) { ------------------ | Branch (579:20): [True: 978, False: 810] ------------------ 580| 978| v = -v; 581| 978| } 582| 1.78k| return c; 583| 1.78k| } 584| | 585| 26.6k| if constexpr (sizeof(T) > 4) { 586| 26.6k| if (is_digit(*c)) { ------------------ | Branch (586:20): [True: 23.9k, False: 2.67k] ------------------ 587| 23.9k| v = v * 10 + (*c - '0'); 588| 23.9k| ++c; 589| 23.9k| } 590| 2.67k| else { 591| 2.67k| if (sign) { ------------------ | Branch (591:23): [True: 1.80k, False: 867] ------------------ 592| 1.80k| v = -v; 593| 1.80k| } 594| 2.67k| return c; 595| 2.67k| } 596| | 597| 23.9k| if (is_digit(*c)) { ------------------ | Branch (597:20): [True: 22.2k, False: 1.75k] ------------------ 598| 22.2k| v = v * 10 + (*c - '0'); 599| 22.2k| ++c; 600| 22.2k| } 601| 1.75k| else { 602| 1.75k| if (sign) { ------------------ | Branch (602:23): [True: 863, False: 889] ------------------ 603| 863| v = -v; 604| 863| } 605| 1.75k| return c; 606| 1.75k| } 607| | 608| 22.2k| if (is_digit(*c)) { ------------------ | Branch (608:20): [True: 20.8k, False: 1.40k] ------------------ 609| 20.8k| v = v * 10 + (*c - '0'); 610| 20.8k| ++c; 611| 20.8k| } 612| 1.40k| else { 613| 1.40k| if (sign) { ------------------ | Branch (613:23): [True: 801, False: 605] ------------------ 614| 801| v = -v; 615| 801| } 616| 1.40k| return c; 617| 1.40k| } 618| | 619| 20.8k| if (is_digit(*c)) { ------------------ | Branch (619:20): [True: 19.5k, False: 1.27k] ------------------ 620| 19.5k| v = v * 10 + (*c - '0'); 621| 19.5k| ++c; 622| 19.5k| } 623| 1.27k| else { 624| 1.27k| if (sign) { ------------------ | Branch (624:23): [True: 592, False: 687] ------------------ 625| 592| v = -v; 626| 592| } 627| 1.27k| return c; 628| 1.27k| } 629| | 630| 19.5k| if (is_digit(*c)) { ------------------ | Branch (630:20): [True: 18.5k, False: 990] ------------------ 631| 18.5k| v = v * 10 + (*c - '0'); 632| 18.5k| ++c; 633| 18.5k| } 634| 990| else { 635| 990| if (sign) { ------------------ | Branch (635:23): [True: 489, False: 501] ------------------ 636| 489| v = -v; 637| 489| } 638| 990| return c; 639| 990| } 640| | 641| 18.5k| if (is_digit(*c)) { ------------------ | Branch (641:20): [True: 16.7k, False: 1.76k] ------------------ 642| 16.7k| v = v * 10 + (*c - '0'); 643| 16.7k| ++c; 644| 16.7k| } 645| 1.76k| else { 646| 1.76k| if (sign) { ------------------ | Branch (646:23): [True: 766, False: 998] ------------------ 647| 766| v = -v; 648| 766| } 649| 1.76k| return c; 650| 1.76k| } 651| | 652| 16.7k| if (is_digit(*c)) { ------------------ | Branch (652:20): [True: 15.5k, False: 1.21k] ------------------ 653| 15.5k| v = v * 10 + (*c - '0'); 654| 15.5k| ++c; 655| 15.5k| } 656| 1.21k| else { 657| 1.21k| if (sign) { ------------------ | Branch (657:23): [True: 508, False: 707] ------------------ 658| 508| v = -v; 659| 508| } 660| 1.21k| return c; 661| 1.21k| } 662| | 663| 15.5k| if (is_digit(*c)) { ------------------ | Branch (663:20): [True: 14.6k, False: 917] ------------------ 664| 14.6k| v = v * 10 + (*c - '0'); 665| 14.6k| ++c; 666| 14.6k| } 667| 917| else { 668| 917| if (sign) { ------------------ | Branch (668:23): [True: 368, False: 549] ------------------ 669| 368| v = -v; 670| 368| } 671| 917| return c; 672| 917| } 673| | 674| 14.6k| if (is_digit(*c)) { ------------------ | Branch (674:20): [True: 10.0k, False: 4.59k] ------------------ 675| 10.0k| v = v * 10 + (*c - '0'); 676| 10.0k| ++c; 677| 10.0k| } 678| 4.59k| else { 679| 4.59k| if (sign) { ------------------ | Branch (679:23): [True: 3.61k, False: 980] ------------------ 680| 3.61k| v = -v; 681| 3.61k| } 682| 4.59k| return c; 683| 4.59k| } 684| 14.6k| } 685| 26.6k| } 686| 37.6k| } 687| | 688| 41.4k| if (is_digit(*c)) { ------------------ | Branch (688:11): [True: 9.11k, False: 32.2k] ------------------ 689| 9.11k| if (sign) { ------------------ | Branch (689:14): [True: 8.01k, False: 1.10k] ------------------ 690| 8.01k| if (would_overflow_negative(v, *c)) [[unlikely]] { ------------------ | Branch (690:17): [True: 6.64k, False: 1.36k] ------------------ 691| 6.64k| return {}; 692| 6.64k| } 693| 1.36k| v = -1 * v; 694| 1.36k| v = v * 10 - (*c - '0'); 695| 1.36k| } 696| 1.10k| else { 697| 1.10k| if (would_overflow_positive(v, *c)) [[unlikely]] { ------------------ | Branch (697:17): [True: 327, False: 781] ------------------ 698| 327| return {}; 699| 327| } 700| 781| v = v * 10 + (*c - '0'); 701| 781| } 702| 2.14k| ++c; 703| 2.14k| if (is_digit(*c)) [[unlikely]] { ------------------ | Branch (703:14): [True: 1.23k, False: 916] ------------------ 704| 1.23k| return {}; 705| 1.23k| } 706| 916| return c; 707| 2.14k| } 708| | 709| 32.2k| if (sign) { ------------------ | Branch (709:11): [True: 411, False: 31.8k] ------------------ 710| 411| v = -v; 711| 411| } 712| 32.2k| return c; 713| 41.4k| } _ZN3glz23would_overflow_negativeIlEEbu17__remove_volatileIT_Eh: 154| 8.01k| { 155| | // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32) 156| 8.01k| using U = std::remove_volatile_t; 157| 8.01k| constexpr auto max_val = static_cast((std::numeric_limits::max)()) + 1; 158| 8.01k| constexpr auto threshold = max_val / 10; 159| 8.01k| constexpr auto last_digit = max_val % 10; 160| 8.01k| const auto uv = static_cast(v); 161| 8.01k| const auto digit = static_cast(next_digit - '0'); 162| | // When digit > last_digit, effective threshold is one less 163| 8.01k| return uv > (threshold - uint64_t(digit > last_digit)); 164| 8.01k| } _ZN3glz23would_overflow_positiveIlEEbu17__remove_volatileIT_Eh: 140| 1.10k| { 141| 1.10k| using U = std::remove_volatile_t; 142| 1.10k| constexpr auto max_val = static_cast((std::numeric_limits::max)()); 143| 1.10k| constexpr auto threshold = max_val / 10; 144| 1.10k| constexpr auto last_digit = max_val % 10; 145| 1.10k| const auto uv = static_cast(v); 146| 1.10k| const auto digit = static_cast(next_digit - '0'); 147| | // When digit > last_digit, effective threshold is one less 148| | // This is branch-free and faster than bitwise OR/AND approach 149| 1.10k| return uv > (threshold - uint64_t(digit > last_digit)); 150| 1.10k| } _ZN3glz9has_quoteEm: 86| 80.8M| { 87| 80.8M| return has_zero(chunk ^ repeat_byte8('"')); 88| 80.8M| } _ZN3glz8has_zeroEm: 81| 141M| { 82| 141M| return (((chunk - 0x0101010101010101ull) & ~chunk) & 0x8080808080808080ull); 83| 141M| } _ZN3glz8has_charILc123EEEmm: 102| 21.0M| { 103| 21.0M| return has_zero(chunk ^ repeat_byte8(Char)); 104| 21.0M| } _ZN3glz8has_charILc125EEEmm: 102| 21.0M| { 103| 21.0M| return has_zero(chunk ^ repeat_byte8(Char)); 104| 21.0M| } _ZN3glz11countr_zeroEm: 29| 9.16M| { 30| |#ifdef _MSC_VER 31| | return std::countr_zero(x); 32| |#else 33| 9.16M|#if __has_builtin(__builtin_ctzll) 34| 9.16M| return __builtin_ctzll(x); 35| |#else 36| | return std::countr_zero(x); 37| |#endif 38| 9.16M|#endif 39| 9.16M| } _ZN3glz8has_charILc91EEEmm: 102| 9.38M| { 103| 9.38M| return has_zero(chunk ^ repeat_byte8(Char)); 104| 9.38M| } _ZN3glz8has_charILc93EEEmm: 102| 9.38M| { 103| 9.38M| return has_zero(chunk ^ repeat_byte8(Char)); 104| 9.38M| } _ZN3glz11countr_zeroEj: 16| 30.3M| { 17| |#ifdef _MSC_VER 18| | return std::countr_zero(x); 19| |#else 20| 30.3M|#if __has_builtin(__builtin_ctzl) 21| 30.3M| return __builtin_ctzl(x); 22| |#else 23| | return std::countr_zero(x); 24| |#endif 25| 30.3M|#endif 26| 30.3M| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 5.84k| { 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| 5.84k| else if constexpr (N == 2) { 304| 5.84k| static constexpr auto packed = pack(); 305| 5.84k| uint16_t in; 306| 5.84k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 5.84k| 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| 5.84k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz5pointELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 1.36k| { 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.36k| else if constexpr (N == 2) { 304| 1.36k| static constexpr auto packed = pack(); 305| 1.36k| uint16_t in; 306| 1.36k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 1.36k| 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.36k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 17.4k| { 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| 17.4k| else if constexpr (N == 6) { 268| 17.4k| static constexpr auto packed = pack_buffered(); 269| 17.4k| uint64_t in{}; 270| 17.4k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 17.4k| 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| 17.4k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm5EcEEbPKT1_: 245| 136| { 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| 136| else if constexpr (N == 5) { 277| 136| static constexpr auto packed = pack(); 278| 136| uint32_t in; 279| 136| std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| 136| 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| 136| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 904| { 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| 904| 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| 904| return 0 == std::memcmp(Str.data(), other, N); 323| 904| } 324| 904| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 722| { 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| 722| else if constexpr (N == 6) { 268| 722| static constexpr auto packed = pack_buffered(); 269| 722| uint64_t in{}; 270| 722| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 722| 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| 722| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 15.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| | 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| 15.6k| else if constexpr (N == 6) { 268| 15.6k| static constexpr auto packed = pack_buffered(); 269| 15.6k| uint64_t in{}; 270| 15.6k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 15.6k| 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| 15.6k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6nestedELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 829| { 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| 829| else if constexpr (N == 6) { 268| 829| static constexpr auto packed = pack_buffered(); 269| 829| uint64_t in{}; 270| 829| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 829| 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| 829| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm4ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 8.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| 8.20k| else if constexpr (N == 7) { 259| 8.20k| static constexpr auto packed = pack_buffered(); 260| 8.20k| uint64_t in{}; 261| 8.20k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 8.20k| 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| 8.20k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm5ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 1.21k| { 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.21k| else if constexpr (N == 6) { 268| 1.21k| static constexpr auto packed = pack_buffered(); 269| 1.21k| uint64_t in{}; 270| 1.21k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 1.21k| 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.21k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm6ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 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| 1.41k| else if constexpr (N == 6) { 268| 1.41k| static constexpr auto packed = pack_buffered(); 269| 1.41k| uint64_t in{}; 270| 1.41k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 1.41k| 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.41k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEvOT1_OT2_T3_E1SELm3EcEEbPKSB_: 245| 1.28k| { 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.28k| else if constexpr (N == 3) { 295| 1.28k| static constexpr auto packed = pack(); 296| 1.28k| uint16_t in; 297| 1.28k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 1.28k| 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.28k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm7ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 1.53k| { 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.53k| if constexpr (N == 8) { 250| 1.53k| static constexpr auto packed = pack(); 251| 1.53k| uint64_t in; 252| 1.53k| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 1.53k| 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.53k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz6amountELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 431| { 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| 431| else if constexpr (N == 6) { 268| 431| static constexpr auto packed = pack_buffered(); 269| 431| uint64_t in{}; 270| 431| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 431| 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| 431| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm8ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 501| { 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| 501| if constexpr (N == 8) { 250| 501| static constexpr auto packed = pack(); 251| 501| uint64_t in; 252| 501| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 501| 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| 501| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm9ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 426| { 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| 426| else if constexpr (N == 6) { 268| 426| static constexpr auto packed = pack_buffered(); 269| 426| uint64_t in{}; 270| 426| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 426| 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| 426| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm10ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 438| { 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| 438| 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| 438| return 0 == std::memcmp(Str.data(), other, N); 323| 438| } 324| 438| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm11ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 323| { 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| 323| else if constexpr (N == 6) { 268| 323| static constexpr auto packed = pack_buffered(); 269| 323| uint64_t in{}; 270| 323| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 323| 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| 323| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiELm12ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 221| { 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| 221| else if constexpr (N == 6) { 268| 221| static constexpr auto packed = pack_buffered(); 269| 221| uint64_t in{}; 270| 221| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 221| 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| 221| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS9_EEvOT1_OT2_T3_E1SELm4EcEEbPKSB_: 245| 871| { 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| 871| else if constexpr (N == 4) { 286| 871| static constexpr auto packed = pack(); 287| 871| uint32_t in; 288| 871| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 871| 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| 871| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 75.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| 75.2k| if constexpr (N == 8) { 250| 75.2k| static constexpr auto packed = pack(); 251| 75.2k| uint64_t in; 252| 75.2k| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 75.2k| 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| 75.2k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 65.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| | 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| 65.1k| else if constexpr (N == 7) { 259| 65.1k| static constexpr auto packed = pack_buffered(); 260| 65.1k| uint64_t in{}; 261| 65.1k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 65.1k| 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| 65.1k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 46.5k| { 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| 46.5k| else if constexpr (N == 7) { 259| 46.5k| static constexpr auto packed = pack_buffered(); 260| 46.5k| uint64_t in{}; 261| 46.5k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 46.5k| 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| 46.5k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENS_3rpc18request_envelope_tELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm3EcEEbPKT1_: 245| 89.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| | 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| 89.1k| else if constexpr (N == 3) { 295| 89.1k| static constexpr auto packed = pack(); 296| 89.1k| uint16_t in; 297| 89.1k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 89.1k| 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| 89.1k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEvOT1_OT2_T3_E1SELm4EcEEbPKSB_: 245| 516k| { 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| 516k| else if constexpr (N == 4) { 286| 516k| static constexpr auto packed = pack(); 287| 516k| uint32_t in; 288| 516k| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 516k| 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| 516k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT1_OT2_T3_E1SELm3EcEEbPKSD_: 245| 3.61k| { 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| 3.61k| else if constexpr (N == 3) { 295| 3.61k| static constexpr auto packed = pack(); 296| 3.61k| uint16_t in; 297| 3.61k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 3.61k| 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.61k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT1_OT2_T3_E1SELm4EcEEbPKSD_: 245| 7.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| 7.11k| else if constexpr (N == 4) { 286| 7.11k| static constexpr auto packed = pack(); 287| 7.11k| uint32_t in; 288| 7.11k| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 7.11k| 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| 7.11k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS6_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT1_OT2_T3_E1SELm3EcEEbPKSD_: 245| 2.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| | 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.43k| else if constexpr (N == 3) { 295| 2.43k| static constexpr auto packed = pack(); 296| 2.43k| uint16_t in; 297| 2.43k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 2.43k| 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.43k| } _ZN3glz10comparitorIL_ZZZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_ENKUlTnmvE_clILm0EEEDavE3keyELm2EcEEbPKSC_: 245| 25.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| | 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| 25.1k| else if constexpr (N == 2) { 304| 25.1k| static constexpr auto packed = pack(); 305| 25.1k| uint16_t in; 306| 25.1k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 25.1k| 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| 25.1k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_EEvSF_OSG_T3_E1SELm3EcEEbPKSE_: 245| 802| { 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| 802| else if constexpr (N == 3) { 295| 802| static constexpr auto packed = pack(); 296| 802| uint16_t in; 297| 802| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 802| 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| 802| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_EEvSF_OSG_T3_E1SELm4EcEEbPKSE_: 245| 787| { 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| 787| else if constexpr (N == 4) { 286| 787| static constexpr auto packed = pack(); 287| 787| uint32_t in; 288| 787| std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| 787| 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| 787| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS6_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES8_SB_SA_EEvSF_OSG_T3_E1SELm3EcEEbPKSE_: 245| 972| { 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| 972| else if constexpr (N == 3) { 295| 972| static constexpr auto packed = pack(); 296| 972| uint16_t in; 297| 972| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 972| 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| 972| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 150| 822k| { 151| 822k| if constexpr (Checked && vector_like) { 152| 822k| if (ix == b.size()) [[unlikely]] { ------------------ | Branch (152:14): [True: 0, False: 822k] ------------------ 153| 0| grow_buffer(b, b.size() == 0 ? 64 : ix + 1); ------------------ | Branch (153:28): [True: 0, False: 0] ------------------ 154| 0| } 155| 822k| } 156| 822k| assign_maybe_cast(c, b, ix); 157| 822k| ++ix; 158| 822k| } _ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm: 95| 822k| { 96| 822k| using V = std::decay_t; 97| 822k| using C = std::decay_t; 98| 822k| if constexpr (std::same_as) { 99| 822k| b[ix] = c; 100| | } 101| | else { 102| | b[ix] = static_cast(c); 103| | } 104| 822k| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 192| 8.84M| { 193| 8.84M| const auto n = str.size(); 194| 8.84M| if constexpr (vector_like) { 195| 8.84M| if constexpr (Checked) { 196| 8.84M| const auto k = ix + n; 197| 8.84M| if (ix + n > b.size()) [[unlikely]] { ------------------ | Branch (197:17): [True: 0, False: 8.84M] ------------------ 198| 0| grow_buffer(b, k); 199| 0| } 200| 8.84M| } 201| 8.84M| } 202| 8.84M| std::memcpy(&b[ix], str.data(), n); 203| 8.84M| ix += n; 204| 8.84M| } _ZN3glz16dump_maybe_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 319| 4.56M| { 320| 4.56M| const auto n = str.size(); 321| 4.56M| if (n) { ------------------ | Branch (321:11): [True: 4.56M, False: 0] ------------------ 322| 4.56M| if constexpr (vector_like) { 323| 4.56M| if constexpr (Checked) { 324| 4.56M| const auto k = ix + n; 325| 4.56M| if (k > b.size()) [[unlikely]] { ------------------ | Branch (325:20): [True: 0, False: 4.56M] ------------------ 326| 0| grow_buffer(b, k); 327| 0| } 328| 4.56M| } 329| 4.56M| } 330| 4.56M| std::memcpy(&b[ix], str.data(), n); 331| 4.56M| ix += n; 332| 4.56M| } 333| 4.56M| } _ZN3glz5dumpnINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT0_mRT_Rm: 222| 273k| { 223| 273k| if constexpr (vector_like) { 224| 273k| const auto k = ix + n; 225| 273k| if (k > b.size()) [[unlikely]] { ------------------ | Branch (225:14): [True: 0, False: 273k] ------------------ 226| 0| grow_buffer(b, k); 227| 0| } 228| 273k| } 229| 273k| fill_bytes(data_at(b, ix), c, n); 230| 273k| ix += n; 231| 273k| } _ZN3glz10fill_bytesIcEEvPT_cm: 54| 273k| { 55| 273k| auto* p = reinterpret_cast(dst); 56| 273k| if (n >= 64) [[unlikely]] { ------------------ | Branch (56:11): [True: 0, False: 273k] ------------------ 57| 0| std::memset(p, c, n); 58| 0| return; 59| 0| } 60| 273k| const uint64_t v = 0x0101010101010101ull * uint8_t(c); 61| 273k| if (n >= 8) { ------------------ | Branch (61:11): [True: 49.7k, False: 223k] ------------------ 62| 49.7k| size_t i = 0; 63| 173k| for (; i + 8 <= n; i += 8) { ------------------ | Branch (63:17): [True: 123k, False: 49.7k] ------------------ 64| 123k| std::memcpy(p + i, &v, 8); 65| 123k| } 66| 49.7k| if (i < n) { ------------------ | Branch (66:14): [True: 43.3k, False: 6.44k] ------------------ 67| 43.3k| std::memcpy(p + n - 8, &v, 8); // overlaps what is already written, stays within n 68| 43.3k| } 69| 49.7k| } 70| 223k| else if (n >= 4) { ------------------ | Branch (70:16): [True: 14.7k, False: 209k] ------------------ 71| 14.7k| std::memcpy(p, &v, 4); 72| 14.7k| std::memcpy(p + n - 4, &v, 4); 73| 14.7k| } 74| 209k| else if (n) { ------------------ | Branch (74:16): [True: 44.2k, False: 164k] ------------------ 75| 44.2k| std::memcpy(p, &v, 1); 76| 44.2k| std::memcpy(p + (n >> 1), &v, 1); 77| 44.2k| std::memcpy(p + n - 1, &v, 1); 78| 44.2k| } 79| 273k| } _ZN3glz7data_atINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEDaRT_m: 117| 273k| { 118| | if constexpr (std::is_pointer_v>) { 119| | return b + ix; 120| | } 121| 273k| else { 122| 273k| static_assert(has_data>, 123| 273k| "an output buffer must be contiguous: dump writes through memset and memcpy"); 124| | if constexpr (has_data_offset>) { 125| | assert(ix >= b.data_offset() && "Index before flush offset"); 126| | return b.data() + (ix - b.data_offset()); 127| | } 128| 273k| else { 129| 273k| return b.data() + ix; 130| 273k| } 131| 273k| } 132| 273k| } _ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 150| 448| { 151| | if constexpr (Checked && vector_like) { 152| | if (ix == b.size()) [[unlikely]] { 153| | grow_buffer(b, b.size() == 0 ? 64 : ix + 1); 154| | } 155| | } 156| 448| assign_maybe_cast(c, b, ix); 157| 448| ++ix; 158| 448| } _ZN3glz10fast_float4spanIKcEC2Ev: 438| 2.57M| constexpr span() : ptr(nullptr), length(0) {} _ZN3glz10fast_float10is_integerIcEEbT_: 1481| 1.04M|fastfloat_really_inline constexpr bool is_integer(UC c) noexcept { 1482| 1.04M| return !(c > UC('9') || c < UC('0')); ------------------ | Branch (1482:12): [True: 3, False: 1.04M] | Branch (1482:27): [True: 41, False: 1.04M] ------------------ 1483| 1.04M|} _ZN3glz10fast_float11digit_valueIcEEmT_: 1489| 8.51M|fastfloat_really_inline constexpr uint64_t digit_value(UC c) noexcept { 1490| 8.51M| return uint64_t(uint8_t(c) - uint8_t('0')); 1491| 8.51M|} _ZN3glz10fast_float4spanIKcEC2EPS2_m: 436| 1.30M| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float26loop_parse_if_eight_digitsERPKcS2_Rm: 1679| 21.7k| uint64_t &i) { 1680| | // optimizes better than parse_if_eight_digits_unrolled() for UC = char. 1681| 1.94M| while ((std::distance(p, pend) >= 8) && ------------------ | Branch (1681:10): [True: 1.94M, False: 1.80k] ------------------ 1682| 1.94M| is_made_of_eight_digits_fast(read8_to_u64(p))) { ------------------ | Branch (1682:10): [True: 1.92M, False: 19.9k] ------------------ 1683| 1.92M| i = i * 100000000 + 1684| 1.92M| parse_eight_digits_unrolled(read8_to_u64( 1685| 1.92M| p)); // in rare cases, this will overflow, but that's ok 1686| 1.92M| p += 8; 1687| 1.92M| } 1688| 21.7k|} _ZN3glz10fast_float28is_made_of_eight_digits_fastEm: 1597| 1.94M|is_made_of_eight_digits_fast(uint64_t val) noexcept { 1598| 1.94M| return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) & 1599| 1.94M| 0x8080808080808080)); 1600| 1.94M|} _ZN3glz10fast_float12read8_to_u64IcEEmPKT_: 1503| 4.18M|read8_to_u64(UC const *chars) { 1504| 4.18M| 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| 4.18M| uint64_t val; 1513| 4.18M| ::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| 4.18M| return val; 1519| 4.18M|} _ZN3glz10fast_float27parse_eight_digits_unrolledEm: 1575| 2.24M|parse_eight_digits_unrolled(uint64_t val) { 1576| 2.24M| uint64_t const mask = 0x000000FF000000FF; 1577| 2.24M| uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32) 1578| 2.24M| uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32) 1579| 2.24M| val -= 0x3030303030303030; 1580| 2.24M| val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8; 1581| 2.24M| val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32; 1582| 2.24M| return uint32_t(val); 1583| 2.24M|} _ZNK3glz10fast_float4spanIKcE3lenEv: 440| 55.4k| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float19from_chars_advancedIdcEENS0_19from_chars_result_tIT0_EERNS0_22parsed_number_string_tIS3_EERT_: 4249| 1.28M|from_chars_advanced(parsed_number_string_t &pns, T &value) noexcept { 4250| | 4251| 1.28M| static_assert(is_supported_float_type::value, 4252| 1.28M| "only some floating-point types are supported"); 4253| 1.28M| static_assert(is_supported_char_type::value, 4254| 1.28M| "only char, wchar_t, char16_t and char32_t are supported"); 4255| | 4256| 1.28M| from_chars_result_t answer; 4257| | 4258| 1.28M| answer.ec = std::errc(); // be optimistic 4259| 1.28M| 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| 1.28M| if (binary_format::min_exponent_fast_path() <= pns.exponent && ------------------ | Branch (4265:7): [True: 1.27M, False: 4.86k] ------------------ 4266| 1.27M| pns.exponent <= binary_format::max_exponent_fast_path() && ------------------ | Branch (4266:7): [True: 1.25M, False: 20.3k] ------------------ 4267| 1.25M| !pns.too_many_digits) { ------------------ | Branch (4267:7): [True: 1.24M, False: 15.4k] ------------------ 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| 1.24M| if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) { ------------------ | Branch (4275:9): [True: 1.24M, Folded] | Branch (4275:38): [True: 1.24M, False: 0] ------------------ 4276| | // We have that fegetround() == FE_TONEAREST. 4277| | // Next is Clinger's fast path. 4278| 1.24M| if (pns.mantissa <= binary_format::max_mantissa_fast_path()) { ------------------ | Branch (4278:11): [True: 1.24M, False: 2.13k] ------------------ 4279| 1.24M| value = T(pns.mantissa); 4280| 1.24M| if (pns.exponent < 0) { ------------------ | Branch (4280:13): [True: 3.84k, False: 1.23M] ------------------ 4281| 3.84k| value = value / binary_format::exact_power_of_ten(-pns.exponent); 4282| 1.23M| } else { 4283| 1.23M| value = value * binary_format::exact_power_of_ten(pns.exponent); 4284| 1.23M| } 4285| 1.24M| if (pns.negative) { ------------------ | Branch (4285:13): [True: 1.04M, False: 195k] ------------------ 4286| 1.04M| value = -value; 4287| 1.04M| } 4288| 1.24M| return answer; 4289| 1.24M| } 4290| 1.24M| } 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| 1.24M| } 4313| 42.7k| adjusted_mantissa am = 4314| 42.7k| compute_float>(pns.exponent, pns.mantissa); 4315| 42.7k| if (pns.too_many_digits && am.power2 >= 0) { ------------------ | Branch (4315:7): [True: 21.1k, False: 21.6k] | Branch (4315:30): [True: 21.1k, False: 0] ------------------ 4316| 21.1k| if (am != compute_float>(pns.exponent, pns.mantissa + 1)) { ------------------ | Branch (4316:9): [True: 13.8k, False: 7.28k] ------------------ 4317| 13.8k| am = compute_error>(pns.exponent, pns.mantissa); 4318| 13.8k| } 4319| 21.1k| } 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| 42.7k| if (am.power2 < 0) { ------------------ | Branch (4323:7): [True: 13.8k, False: 28.9k] ------------------ 4324| 13.8k| am = digit_comp(pns, am); 4325| 13.8k| } 4326| 42.7k| to_float(pns.negative, am, value); 4327| | // Test for over/underflow. 4328| 42.7k| if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) || ------------------ | Branch (4328:8): [True: 27.2k, False: 15.5k] | Branch (4328:29): [True: 1.28k, False: 26.0k] | Branch (4328:49): [True: 105, False: 1.17k] ------------------ 4329| 42.6k| am.power2 == binary_format::infinite_power()) { ------------------ | Branch (4329:7): [True: 185, False: 42.5k] ------------------ 4330| 290| answer.ec = std::errc::result_out_of_range; 4331| 290| } 4332| 42.7k| return answer; 4333| 1.28M|} _ZN3glz10fast_float13binary_formatIdE22min_exponent_fast_pathEv: 695| 1.28M|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| 1.28M| return -22; 700| 1.28M|#endif 701| 1.28M|} _ZN3glz10fast_float13binary_formatIdE22max_exponent_fast_pathEv: 767| 1.27M|inline constexpr int binary_format::max_exponent_fast_path() { 768| 1.27M| return 22; 769| 1.27M|} _ZN3glz10fast_float6detail17rounds_to_nearestEv: 4129| 1.24M|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| 1.24M| static float volatile fmin = (std::numeric_limits::min)(); 4151| 1.24M| 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| 1.24M|#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| 1.24M| 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| 1.24M|} _ZN3glz10fast_float13binary_formatIdE22max_mantissa_fast_pathEv: 777| 1.24M|inline constexpr uint64_t binary_format::max_mantissa_fast_path() { 778| 1.24M| return uint64_t(2) << mantissa_explicit_bits(); 779| 1.24M|} _ZN3glz10fast_float13binary_formatIdE22mantissa_explicit_bitsEv: 713| 1.54M|inline constexpr int binary_format::mantissa_explicit_bits() { 714| 1.54M| return 52; 715| 1.54M|} _ZN3glz10fast_float13binary_formatIdE18exact_power_of_tenEl: 1057| 1.24M|binary_format::exact_power_of_ten(int64_t power) { 1058| | // Work around clang bug https://godbolt.org/z/zedh7rrhc 1059| 1.24M| return (void)powers_of_ten[0], powers_of_ten[power]; 1060| 1.24M|} _ZN3glz10fast_float13compute_floatINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2852| 63.9k|compute_float(int64_t q, uint64_t w) noexcept { 2853| 63.9k| adjusted_mantissa answer; 2854| 63.9k| if ((w == 0) || (q < binary::smallest_power_of_ten())) { ------------------ | Branch (2854:7): [True: 15.5k, False: 48.4k] | Branch (2854:19): [True: 95, False: 48.3k] ------------------ 2855| 15.5k| answer.power2 = 0; 2856| 15.5k| answer.mantissa = 0; 2857| | // result should be zero 2858| 15.5k| return answer; 2859| 15.5k| } 2860| 48.3k| if (q > binary::largest_power_of_ten()) { ------------------ | Branch (2860:7): [True: 221, False: 48.1k] ------------------ 2861| | // we want to get infinity: 2862| 221| answer.power2 = binary::infinite_power(); 2863| 221| answer.mantissa = 0; 2864| 221| return answer; 2865| 221| } 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| 48.1k| int lz = leading_zeroes(w); 2871| 48.1k| 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| 48.1k| value128 product = 2880| 48.1k| 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| 48.1k| int upperbit = int(product.high >> 63); 2891| 48.1k| int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3; 2892| | 2893| 48.1k| answer.mantissa = product.high >> shift; 2894| | 2895| 48.1k| answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - 2896| 48.1k| binary::minimum_exponent()); 2897| 48.1k| if (answer.power2 <= 0) { // we have a subnormal? ------------------ | Branch (2897:7): [True: 3.18k, False: 44.9k] ------------------ 2898| | // Here have that answer.power2 <= 0 so -answer.power2 >= 0 2899| 3.18k| if (-answer.power2 + 1 >= ------------------ | Branch (2899:9): [True: 7, False: 3.17k] ------------------ 2900| 3.18k| 64) { // if we have more than 64 bits below the minimum exponent, you 2901| | // have a zero for sure. 2902| 7| answer.power2 = 0; 2903| 7| answer.mantissa = 0; 2904| | // result should be zero 2905| 7| return answer; 2906| 7| } 2907| | // next line is safe because -answer.power2 + 1 < 64 2908| 3.17k| 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.17k| answer.mantissa += (answer.mantissa & 1); // round up 2913| 3.17k| 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.17k| answer.power2 = 2922| 3.17k| (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ------------------ | Branch (2922:9): [True: 3.17k, False: 0] ------------------ 2923| 3.17k| ? 0 2924| 3.17k| : 1; 2925| 3.17k| return answer; 2926| 3.18k| } 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| 44.9k| if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) && ------------------ | Branch (2931:7): [True: 14.8k, False: 30.0k] | Branch (2931:29): [True: 14.2k, False: 640] ------------------ 2932| 14.2k| (q <= binary::max_exponent_round_to_even()) && ------------------ | Branch (2932:7): [True: 13.6k, False: 563] ------------------ 2933| 13.6k| ((answer.mantissa & 3) == 1)) { // we may fall between two floats! ------------------ | Branch (2933:7): [True: 9.49k, False: 4.15k] ------------------ 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| 9.49k| if ((answer.mantissa << shift) == product.high) { ------------------ | Branch (2939:9): [True: 5.03k, False: 4.45k] ------------------ 2940| 5.03k| answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up 2941| 5.03k| } 2942| 9.49k| } 2943| | 2944| 44.9k| answer.mantissa += (answer.mantissa & 1); // round up 2945| 44.9k| answer.mantissa >>= 1; 2946| 44.9k| if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) { ------------------ | Branch (2946:7): [True: 877, False: 44.0k] ------------------ 2947| 877| answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits()); 2948| 877| answer.power2++; // undo previous addition 2949| 877| } 2950| | 2951| 44.9k| answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits()); 2952| 44.9k| if (answer.power2 >= binary::infinite_power()) { // infinity ------------------ | Branch (2952:7): [True: 17, False: 44.9k] ------------------ 2953| 17| answer.power2 = binary::infinite_power(); 2954| 17| answer.mantissa = 0; 2955| 17| } 2956| 44.9k| return answer; 2957| 48.1k|} _ZN3glz10fast_float17adjusted_mantissaC2Ev: 568| 91.6k| adjusted_mantissa() = default; _ZN3glz10fast_float13binary_formatIdE21smallest_power_of_tenEv: 1077| 48.4k|inline constexpr int binary_format::smallest_power_of_ten() { 1078| 48.4k| return -342; 1079| 48.4k|} _ZN3glz10fast_float13binary_formatIdE20largest_power_of_tenEv: 1068| 48.3k|template <> inline constexpr int binary_format::largest_power_of_ten() { 1069| 48.3k| return 308; 1070| 48.3k|} _ZN3glz10fast_float14leading_zeroesEm: 488| 69.6k|leading_zeroes(uint64_t input_num) { 489| 69.6k| assert(input_num > 0); ------------------ | Branch (489:3): [True: 69.6k, False: 0] ------------------ 490| 69.6k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (490:7): [Folded, False: 69.6k] ------------------ 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| 69.6k| return __builtin_clzll(input_num); 505| 69.6k|#endif 506| 69.6k|} _ZN3glz10fast_float29compute_product_approximationILi55EEENS0_8value128Elm: 2771| 61.9k|compute_product_approximation(int64_t q, uint64_t w) { 2772| 61.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| 61.9k| value128 firstproduct = 2777| 61.9k| full_multiplication(w, powers::power_of_five_128[index]); 2778| 61.9k| static_assert((bit_precision >= 0) && (bit_precision <= 64), 2779| 61.9k| " precision should be in (0,64]"); 2780| 61.9k| constexpr uint64_t precision_mask = 2781| 61.9k| (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision) ------------------ | Branch (2781:7): [True: 0, Folded] ------------------ 2782| 61.9k| : uint64_t(0xFFFFFFFFFFFFFFFF); 2783| 61.9k| if ((firstproduct.high & precision_mask) == ------------------ | Branch (2783:7): [True: 7.45k, False: 54.5k] ------------------ 2784| 61.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| 7.45k| value128 secondproduct = 2789| 7.45k| full_multiplication(w, powers::power_of_five_128[index + 1]); 2790| 7.45k| firstproduct.low += secondproduct.high; 2791| 7.45k| if (secondproduct.high > firstproduct.low) { ------------------ | Branch (2791:9): [True: 3.04k, False: 4.41k] ------------------ 2792| 3.04k| firstproduct.high++; 2793| 3.04k| } 2794| 7.45k| } 2795| 61.9k| return firstproduct; 2796| 61.9k|} _ZN3glz10fast_float19full_multiplicationEmm: 540| 69.4k|full_multiplication(uint64_t a, uint64_t b) { 541| 69.4k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (541:7): [Folded, False: 69.4k] ------------------ 542| 0| value128 answer; 543| 0| answer.low = umul128_generic(a, b, &answer.high); 544| 0| return answer; 545| 0| } 546| 69.4k| 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| 69.4k| answer.low = uint64_t(r); 558| 69.4k| answer.high = uint64_t(r >> 64); 559| |#else 560| | answer.low = umul128_generic(a, b, &answer.high); 561| |#endif 562| 69.4k| return answer; 563| 69.4k|} _ZN3glz10fast_float8value128C2Ev: 454| 69.4k| constexpr value128() : low(0), high(0) {} _ZN3glz10fast_float6detail5powerEi: 2814| 61.9k|constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept { 2815| 61.9k| return (((152170 + 65536) * q) >> 16) + 63; 2816| 61.9k|} _ZN3glz10fast_float13binary_formatIdE16minimum_exponentEv: 742| 75.8k|template <> inline constexpr int binary_format::minimum_exponent() { 743| 75.8k| return -1023; 744| 75.8k|} _ZN3glz10fast_float13binary_formatIdE26min_exponent_round_to_evenEv: 733| 14.8k|inline constexpr int binary_format::min_exponent_round_to_even() { 734| 14.8k| return -4; 735| 14.8k|} _ZN3glz10fast_float13binary_formatIdE26max_exponent_round_to_evenEv: 723| 14.2k|inline constexpr int binary_format::max_exponent_round_to_even() { 724| 14.2k| return 23; 725| 14.2k|} _ZNK3glz10fast_float17adjusted_mantissaneERKS1_: 574| 21.1k| constexpr bool operator!=(adjusted_mantissa const &o) const { 575| 21.1k| return mantissa != o.mantissa || power2 != o.power2; ------------------ | Branch (575:12): [True: 13.8k, False: 7.28k] | Branch (575:38): [True: 0, False: 7.28k] ------------------ 576| 21.1k| } _ZN3glz10fast_float13compute_errorINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2837| 13.8k|compute_error(int64_t q, uint64_t w) noexcept { 2838| 13.8k| int lz = leading_zeroes(w); 2839| 13.8k| w <<= lz; 2840| 13.8k| value128 product = 2841| 13.8k| compute_product_approximation(q, w); 2842| 13.8k| return compute_error_scaled(q, product.high, lz); 2843| 13.8k|} _ZN3glz10fast_float20compute_error_scaledINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElmi: 2823| 13.8k|compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept { 2824| 13.8k| int hilz = int(w >> 63) ^ 1; 2825| 13.8k| adjusted_mantissa answer; 2826| 13.8k| answer.mantissa = w << hilz; 2827| 13.8k| int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent(); 2828| 13.8k| answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + 2829| 13.8k| invalid_am_bias); 2830| 13.8k| return answer; 2831| 13.8k|} _ZN3glz10fast_float10digit_compIdcEENS0_17adjusted_mantissaERNS0_22parsed_number_string_tIT0_EES2_: 4034| 13.8k|digit_comp(parsed_number_string_t &num, adjusted_mantissa am) noexcept { 4035| | // remove the invalid exponent bias 4036| 13.8k| am.power2 -= invalid_am_bias; 4037| | 4038| 13.8k| int32_t sci_exp = scientific_exponent(num); 4039| 13.8k| size_t max_digits = binary_format::max_digits(); 4040| 13.8k| size_t digits = 0; 4041| 13.8k| bigint bigmant; 4042| 13.8k| parse_mantissa(bigmant, num, max_digits, digits); 4043| | // can't underflow, since digits is at most max_digits. 4044| 13.8k| int32_t exponent = sci_exp + 1 - int32_t(digits); 4045| 13.8k| if (exponent >= 0) { ------------------ | Branch (4045:7): [True: 3.82k, False: 10.0k] ------------------ 4046| 3.82k| return positive_digit_comp(bigmant, exponent); 4047| 10.0k| } else { 4048| 10.0k| return negative_digit_comp(bigmant, am, exponent); 4049| 10.0k| } 4050| 13.8k|} _ZN3glz10fast_float19scientific_exponentIcEEiRNS0_22parsed_number_string_tIT_EE: 3640| 13.8k|scientific_exponent(parsed_number_string_t &num) noexcept { 3641| 13.8k| uint64_t mantissa = num.mantissa; 3642| 13.8k| int32_t exponent = int32_t(num.exponent); 3643| 69.2k| while (mantissa >= 10000) { ------------------ | Branch (3643:10): [True: 55.4k, False: 13.8k] ------------------ 3644| 55.4k| mantissa /= 10000; 3645| 55.4k| exponent += 4; 3646| 55.4k| } 3647| 27.7k| while (mantissa >= 100) { ------------------ | Branch (3647:10): [True: 13.8k, False: 13.8k] ------------------ 3648| 13.8k| mantissa /= 100; 3649| 13.8k| exponent += 2; 3650| 13.8k| } 3651| 13.8k| while (mantissa >= 10) { ------------------ | Branch (3651:10): [True: 0, False: 13.8k] ------------------ 3652| 0| mantissa /= 10; 3653| 0| exponent += 1; 3654| 0| } 3655| 13.8k| return exponent; 3656| 13.8k|} _ZN3glz10fast_float13binary_formatIdE10max_digitsEv: 1085| 13.8k|template <> inline constexpr size_t binary_format::max_digits() { 1086| 13.8k| return 769; 1087| 13.8k|} _ZN3glz10fast_float6bigintC2Ev: 3399| 13.8k| GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {} _ZN3glz10fast_float8stackvecILt62EEC2Ev: 3006| 104k| stackvec() = default; _ZN3glz10fast_float14parse_mantissaIcEEvRNS0_6bigintERNS0_22parsed_number_string_tIT_EEmRm: 3859| 13.8k| 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| 13.8k| size_t counter = 0; 3864| 13.8k| digits = 0; 3865| 13.8k| limb value = 0; 3866| 13.8k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3867| 13.8k| size_t step = 19; 3868| |#else 3869| | size_t step = 9; 3870| |#endif 3871| | 3872| | // process all integer digits. 3873| 13.8k| UC const *p = num.integer.ptr; 3874| 13.8k| UC const *pend = p + num.integer.len(); 3875| 13.8k| skip_zeros(p, pend); 3876| | // process all digits, in increments of step per loop 3877| 31.4k| while (p != pend) { ------------------ | Branch (3877:10): [True: 17.5k, False: 13.8k] ------------------ 3878| 42.8k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3878:12): [True: 30.1k, False: 12.6k] | Branch (3878:45): [True: 25.2k, False: 4.95k] ------------------ 3879| 25.2k| (max_digits - digits >= 8)) { ------------------ | Branch (3879:12): [True: 25.2k, False: 0] ------------------ 3880| 25.2k| parse_eight_digits(p, value, counter, digits); 3881| 25.2k| } 3882| 63.6k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3882:12): [True: 53.4k, False: 10.1k] | Branch (3882:30): [True: 46.1k, False: 7.37k] | Branch (3882:43): [True: 46.1k, False: 0] ------------------ 3883| 46.1k| parse_one_digit(p, value, counter, digits); 3884| 46.1k| } 3885| 17.5k| if (digits == max_digits) { ------------------ | Branch (3885:9): [True: 0, False: 17.5k] ------------------ 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| 17.5k| } else { 3897| 17.5k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3898| 17.5k| counter = 0; 3899| 17.5k| value = 0; 3900| 17.5k| } 3901| 17.5k| } 3902| | 3903| | // add our fraction digits, if they're available. 3904| 13.8k| if (num.fraction.ptr != nullptr) { ------------------ | Branch (3904:7): [True: 11.3k, False: 2.55k] ------------------ 3905| 11.3k| p = num.fraction.ptr; 3906| 11.3k| pend = p + num.fraction.len(); 3907| 11.3k| if (digits == 0) { ------------------ | Branch (3907:9): [True: 2.51k, False: 8.78k] ------------------ 3908| 2.51k| skip_zeros(p, pend); 3909| 2.51k| } 3910| | // process all digits, in increments of step per loop 3911| 162k| while (p != pend) { ------------------ | Branch (3911:12): [True: 154k, False: 8.34k] ------------------ 3912| 449k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3912:14): [True: 438k, False: 10.7k] | Branch (3912:47): [True: 296k, False: 141k] ------------------ 3913| 296k| (max_digits - digits >= 8)) { ------------------ | Branch (3913:14): [True: 294k, False: 1.73k] ------------------ 3914| 294k| parse_eight_digits(p, value, counter, digits); 3915| 294k| } 3916| 612k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3916:14): [True: 469k, False: 143k] | Branch (3916:32): [True: 460k, False: 8.54k] | Branch (3916:45): [True: 458k, False: 2.19k] ------------------ 3917| 458k| parse_one_digit(p, value, counter, digits); 3918| 458k| } 3919| 154k| if (digits == max_digits) { ------------------ | Branch (3919:11): [True: 2.95k, False: 151k] ------------------ 3920| | // add the temporary value, then check if we've truncated any digits 3921| 2.95k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3922| 2.95k| bool truncated = is_truncated(p, pend); 3923| 2.95k| if (truncated) { ------------------ | Branch (3923:13): [True: 1.91k, False: 1.03k] ------------------ 3924| 1.91k| round_up_bigint(result, digits); 3925| 1.91k| } 3926| 2.95k| return; 3927| 151k| } else { 3928| 151k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3929| 151k| counter = 0; 3930| 151k| value = 0; 3931| 151k| } 3932| 154k| } 3933| 11.3k| } 3934| | 3935| 10.8k| if (counter != 0) { ------------------ | Branch (3935:7): [True: 0, False: 10.8k] ------------------ 3936| 0| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3937| 0| } 3938| 10.8k|} _ZN3glz10fast_float10skip_zerosIcEEvRPKT_S4_: 3773| 16.3k|skip_zeros(UC const *&first, UC const *last) noexcept { 3774| 16.3k| uint64_t val; 3775| 43.3k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3775:10): [True: 43.3k, Folded] ------------------ 3776| 43.3k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3776:10): [True: 39.1k, False: 4.20k] ------------------ 3777| 39.1k| ::memcpy(&val, first, sizeof(uint64_t)); 3778| 39.1k| if (val != int_cmp_zeros()) { ------------------ | Branch (3778:9): [True: 12.1k, False: 26.9k] ------------------ 3779| 12.1k| break; 3780| 12.1k| } 3781| 26.9k| first += int_cmp_len(); 3782| 26.9k| } 3783| 22.6k| while (first != last) { ------------------ | Branch (3783:10): [True: 20.1k, False: 2.51k] ------------------ 3784| 20.1k| if (*first != UC('0')) { ------------------ | Branch (3784:9): [True: 13.8k, False: 6.28k] ------------------ 3785| 13.8k| break; 3786| 13.8k| } 3787| 6.28k| first++; 3788| 6.28k| } 3789| 16.3k|} _ZN3glz10fast_float11int_cmp_lenIcEEiv: 1180| 190k|template constexpr int int_cmp_len() { 1181| 190k| return sizeof(uint64_t) / sizeof(UC); 1182| 190k|} _ZN3glz10fast_float13int_cmp_zerosIcEEmv: 1170| 98.6k|template constexpr uint64_t int_cmp_zeros() { 1171| 98.6k| static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4), 1172| 98.6k| "Unsupported character size"); 1173| 98.6k| return (sizeof(UC) == 1) ? 0x3030303030303030 ------------------ | Branch (1173:10): [True: 98.6k, Folded] ------------------ 1174| 98.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| 98.6k|} _ZN3glz10fast_float18parse_eight_digitsIcEEvRPKT_RmS6_S6_: 3824| 320k| size_t &count) noexcept { 3825| 320k| value = value * 100000000 + parse_eight_digits_unrolled(p); 3826| 320k| p += 8; 3827| 320k| counter += 8; 3828| 320k| count += 8; 3829| 320k|} _ZN3glz10fast_float27parse_eight_digits_unrolledIcEEjPKT_: 1588| 320k|parse_eight_digits_unrolled(UC const *chars) noexcept { 1589| 320k| if (cpp20_and_in_constexpr() || !has_simd_opt()) { ------------------ | Branch (1589:7): [Folded, False: 0] | Branch (1589:35): [True: 0, Folded] ------------------ 1590| 320k| return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay 1591| 320k| } 1592| 0| return parse_eight_digits_unrolled(simd_read8_to_u64(chars)); 1593| 320k|} _ZN3glz10fast_float15parse_one_digitIcEEvRPKT_RmS6_S6_: 3834| 504k| size_t &count) noexcept { 3835| 504k| value = value * 10 + limb(*p - UC('0')); 3836| 504k| p++; 3837| 504k| counter++; 3838| 504k| count++; 3839| 504k|} _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| 301k| limb y) noexcept { 3250| 301k| limb carry = 0; 3251| 4.41M| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3251:26): [True: 4.11M, False: 301k] ------------------ 3252| 4.11M| vec[index] = scalar_mul(vec[index], y, carry); 3253| 4.11M| } 3254| 301k| if (carry != 0) { ------------------ | Branch (3254:7): [True: 272k, False: 28.5k] ------------------ 3255| 272k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 272k| { \ | | 355| 272k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 272k] | | ------------------ | | 356| 272k| return false; \ | | 357| 272k| } ------------------ 3256| 272k| } 3257| 301k| return true; 3258| 301k|} _ZNK3glz10fast_float8stackvecILt62EE3lenEv: 3039| 5.77M| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float10scalar_mulEmmRm: 3196| 4.11M|scalar_mul(limb x, limb y, limb &carry) noexcept { 3197| 4.11M|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3198| 4.11M|#if defined(__SIZEOF_INT128__) 3199| | // GCC and clang both define it as an extension. 3200| 4.11M| __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry); 3201| 4.11M| carry = limb(z >> limb_bits); 3202| 4.11M| 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| 4.11M|} _ZN3glz10fast_float8stackvecILt62EEixEm: 3017| 10.2M| GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept { 3018| 10.2M| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 10.2M| { ((void)(x)); } ------------------ 3019| 10.2M| return data[index]; 3020| 10.2M| } _ZN3glz10fast_float8stackvecILt62EE8try_pushEm: 3052| 290k| GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept { 3053| 290k| if (len() < capacity()) { ------------------ | Branch (3053:9): [True: 290k, False: 0] ------------------ 3054| 290k| push_unchecked(value); 3055| 290k| return true; 3056| 290k| } else { 3057| 0| return false; 3058| 0| } 3059| 290k| } _ZNK3glz10fast_float8stackvecILt62EE8capacityEv: 3043| 478k| constexpr size_t capacity() const noexcept { return size; } _ZN3glz10fast_float8stackvecILt62EE14push_uncheckedEm: 3046| 300k| GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept { 3047| 300k| data[length] = value; 3048| 300k| length++; 3049| 300k| } _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| 236k| while (carry != 0 && index < vec.len()) { ------------------ | Branch (3228:10): [True: 76.3k, False: 159k] | Branch (3228:24): [True: 62.0k, False: 14.2k] ------------------ 3229| 62.0k| vec[index] = scalar_add(vec[index], carry, overflow); 3230| 62.0k| carry = limb(overflow); 3231| 62.0k| index += 1; 3232| 62.0k| } 3233| 173k| if (carry != 0) { ------------------ | Branch (3233:7): [True: 14.2k, False: 159k] ------------------ 3234| 14.2k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 14.2k| { \ | | 355| 14.2k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.2k] | | ------------------ | | 356| 14.2k| return false; \ | | 357| 14.2k| } ------------------ 3235| 14.2k| } 3236| 173k| return true; 3237| 173k|} _ZN3glz10fast_float10scalar_addEmmRb: 3176| 1.22M|scalar_add(limb x, limb y, bool &overflow) noexcept { 3177| 1.22M| limb z; 3178| |// gcc and clang 3179| 1.22M|#if defined(__has_builtin) 3180| 1.22M|#if __has_builtin(__builtin_add_overflow) 3181| 1.22M| if (!cpp20_and_in_constexpr()) { ------------------ | Branch (3181:7): [True: 1.22M, Folded] ------------------ 3182| 1.22M| overflow = __builtin_add_overflow(x, y, &z); 3183| 1.22M| return z; 3184| 1.22M| } 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.22M|} _ZN3glz10fast_float12is_truncatedIcEEbPKT_S4_: 3795| 2.95k|is_truncated(UC const *first, UC const *last) noexcept { 3796| | // do 8-bit optimizations, can just compare to 8 literal 0s. 3797| 2.95k| uint64_t val; 3798| 61.3k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3798:10): [True: 61.3k, Folded] ------------------ 3799| 61.3k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3799:10): [True: 59.4k, False: 1.94k] ------------------ 3800| 59.4k| ::memcpy(&val, first, sizeof(uint64_t)); 3801| 59.4k| if (val != int_cmp_zeros()) { ------------------ | Branch (3801:9): [True: 1.01k, False: 58.4k] ------------------ 3802| 1.01k| return true; 3803| 1.01k| } 3804| 58.4k| first += int_cmp_len(); 3805| 58.4k| } 3806| 7.09k| while (first != last) { ------------------ | Branch (3806:10): [True: 6.05k, False: 1.03k] ------------------ 3807| 6.05k| if (*first != UC('0')) { ------------------ | Branch (3807:9): [True: 906, False: 5.15k] ------------------ 3808| 906| return true; 3809| 906| } 3810| 5.15k| ++first; 3811| 5.15k| } 3812| 1.03k| return false; 3813| 1.94k|} _ZN3glz10fast_float15round_up_bigintERNS0_6bigintERm: 3848| 1.91k|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.91k| add_native(big, 10, 1); 3852| 1.91k| count++; 3853| 1.91k|} _ZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEi: 3942| 3.82k|positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept { 3943| 3.82k| GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent))); ------------------ | | 344| 3.82k| { ((void)(x)); } ------------------ 3944| 3.82k| adjusted_mantissa answer; 3945| 3.82k| bool truncated; 3946| 3.82k| answer.mantissa = bigmant.hi64(truncated); 3947| 3.82k| int bias = binary_format::mantissa_explicit_bits() - 3948| 3.82k| binary_format::minimum_exponent(); 3949| 3.82k| answer.power2 = bigmant.bit_length() - 64 + bias; 3950| | 3951| 3.82k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 3.82k| round_nearest_tie_even( 3953| 3.82k| a, shift, 3954| 3.82k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.82k| return is_above || (is_halfway && truncated) || 3956| 3.82k| (is_odd && is_halfway); 3957| 3.82k| }); 3958| 3.82k| }); 3959| | 3960| 3.82k| return answer; 3961| 3.82k|} _ZN3glz10fast_float6bigint5pow10Ej: 3591| 3.82k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept { 3592| 3.82k| GLZ_FASTFLOAT_TRY(pow5(exp)); ------------------ | | 354| 3.82k| { \ | | 355| 3.82k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 3.82k] | | ------------------ | | 356| 3.82k| return false; \ | | 357| 3.82k| } ------------------ 3593| 3.82k| return pow2(exp); 3594| 3.82k| } _ZN3glz10fast_float6bigint4pow5Ej: 3560| 13.8k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept { 3561| | // multiply by a power of 5 3562| 13.8k| size_t large_length = sizeof(large_power_of_5) / sizeof(limb); 3563| 13.8k| limb_span large = limb_span(large_power_of_5, large_length); 3564| 34.1k| while (exp >= large_step) { ------------------ | Branch (3564:12): [True: 20.2k, False: 13.8k] ------------------ 3565| 20.2k| GLZ_FASTFLOAT_TRY(large_mul(vec, large)); ------------------ | | 354| 20.2k| { \ | | 355| 20.2k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 20.2k] | | ------------------ | | 356| 20.2k| return false; \ | | 357| 20.2k| } ------------------ 3566| 20.2k| exp -= large_step; 3567| 20.2k| } 3568| 13.8k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3569| 13.8k| uint32_t small_step = 27; 3570| 13.8k| limb max_native = 7450580596923828125UL; 3571| |#else 3572| | uint32_t small_step = 13; 3573| | limb max_native = 1220703125U; 3574| |#endif 3575| 28.5k| while (exp >= small_step) { ------------------ | Branch (3575:12): [True: 14.6k, False: 13.8k] ------------------ 3576| 14.6k| GLZ_FASTFLOAT_TRY(small_mul(vec, max_native)); ------------------ | | 354| 14.6k| { \ | | 355| 14.6k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.6k] | | ------------------ | | 356| 14.6k| return false; \ | | 357| 14.6k| } ------------------ 3577| 14.6k| exp -= small_step; 3578| 14.6k| } 3579| 13.8k| if (exp != 0) { ------------------ | Branch (3579:9): [True: 11.2k, False: 2.59k] ------------------ 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| 11.2k| GLZ_FASTFLOAT_TRY(small_mul( ------------------ | | 354| 11.2k| { \ | | 355| 11.2k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 11.2k] | | ------------------ | | 356| 11.2k| return false; \ | | 357| 11.2k| } ------------------ 3584| 11.2k| vec, limb(((void)small_power_of_5[0], small_power_of_5[exp])))); 3585| 11.2k| } 3586| | 3587| 13.8k| return true; 3588| 13.8k| } _ZN3glz10fast_float4spanImEC2EPKmm: 436| 135k| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float9large_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3329| 20.2k|GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec &x, limb_span y) noexcept { 3330| 20.2k| if (y.len() == 1) { ------------------ | Branch (3330:7): [True: 0, False: 20.2k] ------------------ 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| 20.2k| } else { 3333| 20.2k| GLZ_FASTFLOAT_TRY(long_mul(x, y)); ------------------ | | 354| 20.2k| { \ | | 355| 20.2k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 20.2k] | | ------------------ | | 356| 20.2k| return false; \ | | 357| 20.2k| } ------------------ 3334| 20.2k| } 3335| 20.2k| return true; 3336| 20.2k|} _ZNK3glz10fast_float4spanImE3lenEv: 440| 1.52M| constexpr size_t len() const noexcept { return length; } _ZNK3glz10fast_float4spanImEixEm: 442| 934k| GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept { 443| 934k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 934k| { ((void)(x)); } ------------------ 444| 934k| return ptr[index]; 445| 934k| } _ZN3glz10fast_float8long_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3301| 20.2k|GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec &x, limb_span y) noexcept { 3302| 20.2k| limb_span xs = limb_span(x.data, x.len()); 3303| 20.2k| stackvec z(xs); 3304| 20.2k| limb_span zs = limb_span(z.data, z.len()); 3305| | 3306| 20.2k| if (y.len() != 0) { ------------------ | Branch (3306:7): [True: 20.2k, False: 0] ------------------ 3307| 20.2k| limb y0 = y[0]; 3308| 20.2k| GLZ_FASTFLOAT_TRY(small_mul(x, y0)); ------------------ | | 354| 20.2k| { \ | | 355| 20.2k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 20.2k] | | ------------------ | | 356| 20.2k| return false; \ | | 357| 20.2k| } ------------------ 3309| 101k| for (size_t index = 1; index < y.len(); index++) { ------------------ | Branch (3309:28): [True: 81.0k, False: 20.2k] ------------------ 3310| 81.0k| limb yi = y[index]; 3311| 81.0k| stackvec zi; 3312| 81.0k| if (yi != 0) { ------------------ | Branch (3312:11): [True: 81.0k, False: 0] ------------------ 3313| | // re-use the same buffer throughout 3314| 81.0k| zi.set_len(0); 3315| 81.0k| GLZ_FASTFLOAT_TRY(zi.try_extend(zs)); ------------------ | | 354| 81.0k| { \ | | 355| 81.0k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 81.0k] | | ------------------ | | 356| 81.0k| return false; \ | | 357| 81.0k| } ------------------ 3316| 81.0k| GLZ_FASTFLOAT_TRY(small_mul(zi, yi)); ------------------ | | 354| 81.0k| { \ | | 355| 81.0k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 81.0k] | | ------------------ | | 356| 81.0k| return false; \ | | 357| 81.0k| } ------------------ 3317| 81.0k| limb_span zis = limb_span(zi.data, zi.len()); 3318| 81.0k| GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index)); ------------------ | | 354| 81.0k| { \ | | 355| 81.0k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 81.0k] | | ------------------ | | 356| 81.0k| return false; \ | | 357| 81.0k| } ------------------ 3319| 81.0k| } 3320| 81.0k| } 3321| 20.2k| } 3322| | 3323| 20.2k| x.normalize(); 3324| 20.2k| return true; 3325| 20.2k|} _ZN3glz10fast_float8stackvecILt62EEC2ENS0_4spanImEE: 3013| 20.2k| GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) { 3014| 20.2k| GLZ_FASTFLOAT_ASSERT(try_extend(s)); ------------------ | | 344| 20.2k| { ((void)(x)); } ------------------ 3015| 20.2k| } _ZN3glz10fast_float8stackvecILt62EE7set_lenEm: 3035| 268k| GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept { 3036| 268k| length = uint16_t(len); 3037| 268k| } _ZN3glz10fast_float8stackvecILt62EE10try_extendENS0_4spanImEE: 3069| 101k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept { 3070| 101k| if (len() + s.len() <= capacity()) { ------------------ | Branch (3070:9): [True: 101k, False: 0] ------------------ 3071| 101k| extend_unchecked(s); 3072| 101k| return true; 3073| 101k| } else { 3074| 0| return false; 3075| 0| } 3076| 101k| } _ZN3glz10fast_float8stackvecILt62EE16extend_uncheckedENS0_4spanImEE: 3062| 101k| GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept { 3063| 101k| limb *ptr = data + length; 3064| 101k| std::copy_n(s.ptr, s.len(), ptr); 3065| 101k| set_len(len() + s.len()); 3066| 101k| } _ZN3glz10fast_float14large_add_fromILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEEm: 3264| 81.0k| 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| 81.0k| if (x.len() < start || y.len() > x.len() - start) { ------------------ | Branch (3267:7): [True: 0, False: 81.0k] | Branch (3267:26): [True: 79.8k, False: 1.14k] ------------------ 3268| 79.8k| GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0)); ------------------ | | 354| 79.8k| { \ | | 355| 79.8k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 79.8k] | | ------------------ | | 356| 79.8k| return false; \ | | 357| 79.8k| } ------------------ 3269| 79.8k| } 3270| | 3271| 81.0k| bool carry = false; 3272| 914k| for (size_t index = 0; index < y.len(); index++) { ------------------ | Branch (3272:26): [True: 833k, False: 81.0k] ------------------ 3273| 833k| limb xi = x[index + start]; 3274| 833k| limb yi = y[index]; 3275| 833k| bool c1 = false; 3276| 833k| bool c2 = false; 3277| 833k| xi = scalar_add(xi, yi, c1); 3278| 833k| if (carry) { ------------------ | Branch (3278:9): [True: 329k, False: 503k] ------------------ 3279| 329k| xi = scalar_add(xi, 1, c2); 3280| 329k| } 3281| 833k| x[index + start] = xi; 3282| 833k| carry = c1 | c2; 3283| 833k| } 3284| | 3285| | // handle overflow 3286| 81.0k| if (carry) { ------------------ | Branch (3286:7): [True: 0, False: 81.0k] ------------------ 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| 81.0k| return true; 3290| 81.0k|} _ZN3glz10fast_float8stackvecILt62EE10try_resizeEmm: 3095| 79.8k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept { 3096| 79.8k| if (new_len > capacity()) { ------------------ | Branch (3096:9): [True: 0, False: 79.8k] ------------------ 3097| 0| return false; 3098| 79.8k| } else { 3099| 79.8k| resize_unchecked(new_len, value); 3100| 79.8k| return true; 3101| 79.8k| } 3102| 79.8k| } _ZN3glz10fast_float8stackvecILt62EE16resize_uncheckedEmm: 3082| 79.8k| void resize_unchecked(size_t new_len, limb value) noexcept { 3083| 79.8k| if (new_len > len()) { ------------------ | Branch (3083:9): [True: 79.8k, False: 0] ------------------ 3084| 79.8k| size_t count = new_len - len(); 3085| 79.8k| limb *first = data + len(); 3086| 79.8k| limb *last = first + count; 3087| 79.8k| ::std::fill(first, last, value); 3088| 79.8k| set_len(new_len); 3089| 79.8k| } else { 3090| 0| set_len(new_len); 3091| 0| } 3092| 79.8k| } _ZN3glz10fast_float8stackvecILt62EE9normalizeEv: 3118| 30.2k| GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept { 3119| 30.2k| while (len() > 0 && rindex(0) == 0) { ------------------ | Branch (3119:12): [True: 30.2k, False: 0] | Branch (3119:25): [True: 0, False: 30.2k] ------------------ 3120| 0| length--; 3121| 0| } 3122| 30.2k| } _ZNK3glz10fast_float8stackvecILt62EE6rindexEm: 3028| 43.2k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept { 3029| 43.2k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 43.2k| { ((void)(x)); } ------------------ 3030| 43.2k| size_t rindex = length - index - 1; 3031| 43.2k| return data[rindex]; 3032| 43.2k| } _ZN3glz10fast_float6bigint4pow2Ej: 3557| 13.6k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); } _ZN3glz10fast_float6bigint3shlEm: 3519| 13.6k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept { 3520| 13.6k| size_t rem = n % limb_bits; 3521| 13.6k| size_t div = n / limb_bits; 3522| 13.6k| if (rem != 0) { ------------------ | Branch (3522:9): [True: 10.9k, False: 2.67k] ------------------ 3523| 10.9k| GLZ_FASTFLOAT_TRY(shl_bits(rem)); ------------------ | | 354| 10.9k| { \ | | 355| 10.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 10.9k] | | ------------------ | | 356| 10.9k| return false; \ | | 357| 10.9k| } ------------------ 3524| 10.9k| } 3525| 13.6k| if (div != 0) { ------------------ | Branch (3525:9): [True: 6.60k, False: 7.05k] ------------------ 3526| 6.60k| GLZ_FASTFLOAT_TRY(shl_limbs(div)); ------------------ | | 354| 6.60k| { \ | | 355| 6.60k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 6.60k] | | ------------------ | | 356| 6.60k| return false; \ | | 357| 6.60k| } ------------------ 3527| 6.60k| } 3528| 13.6k| return true; 3529| 13.6k| } _ZN3glz10fast_float6bigint8shl_bitsEm: 3472| 10.9k| 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| 10.9k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 10.9k| { ((void)(x)); } ------------------ 3479| 10.9k| GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8); ------------------ | | 349| 10.9k| { ((void)(x)); } ------------------ 3480| | 3481| 10.9k| size_t shl = n; 3482| 10.9k| size_t shr = limb_bits - shl; 3483| 10.9k| limb prev = 0; 3484| 136k| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3484:28): [True: 125k, False: 10.9k] ------------------ 3485| 125k| limb xi = vec[index]; 3486| 125k| vec[index] = (xi << shl) | (prev >> shr); 3487| 125k| prev = xi; 3488| 125k| } 3489| | 3490| 10.9k| limb carry = prev >> shr; 3491| 10.9k| if (carry != 0) { ------------------ | Branch (3491:9): [True: 3.96k, False: 7.01k] ------------------ 3492| 3.96k| return vec.try_push(carry); 3493| 3.96k| } 3494| 7.01k| return true; 3495| 10.9k| } _ZN3glz10fast_float6bigint9shl_limbsEm: 3498| 6.60k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept { 3499| 6.60k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 6.60k| { ((void)(x)); } ------------------ 3500| 6.60k| if (n + vec.len() > vec.capacity()) { ------------------ | Branch (3500:9): [True: 0, False: 6.60k] ------------------ 3501| 0| return false; 3502| 6.60k| } else if (!vec.is_empty()) { ------------------ | Branch (3502:16): [True: 6.60k, False: 0] ------------------ 3503| | // move limbs 3504| 6.60k| limb *dst = vec.data + n; 3505| 6.60k| limb const *src = vec.data; 3506| 6.60k| std::copy_backward(src, src + vec.len(), dst + vec.len()); 3507| | // fill in empty limbs 3508| 6.60k| limb *first = vec.data; 3509| 6.60k| limb *last = first + n; 3510| 6.60k| ::std::fill(first, last, 0); 3511| 6.60k| vec.set_len(n + vec.len()); 3512| 6.60k| return true; 3513| 6.60k| } else { 3514| 0| return true; 3515| 0| } 3516| 6.60k| } _ZNK3glz10fast_float8stackvecILt62EE8is_emptyEv: 3041| 10.4k| constexpr bool is_empty() const noexcept { return length == 0; } _ZNK3glz10fast_float6bigint4hi64ERb: 3418| 3.82k| GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept { 3419| 3.82k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3420| 3.82k| if (vec.len() == 0) { ------------------ | Branch (3420:9): [True: 0, False: 3.82k] ------------------ 3421| 0| return empty_hi64(truncated); 3422| 3.82k| } else if (vec.len() == 1) { ------------------ | Branch (3422:16): [True: 686, False: 3.14k] ------------------ 3423| 686| return uint64_hi64(vec.rindex(0), truncated); 3424| 3.14k| } else { 3425| 3.14k| uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated); 3426| 3.14k| truncated |= vec.nonzero(2); 3427| 3.14k| return result; 3428| 3.14k| } 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| 3.82k| } _ZN3glz10fast_float11uint64_hi64EmRb: 3132| 686|uint64_hi64(uint64_t r0, bool &truncated) noexcept { 3133| 686| truncated = false; 3134| 686| int shl = leading_zeroes(r0); 3135| 686| return r0 << shl; 3136| 686|} _ZN3glz10fast_float11uint64_hi64EmmRb: 3139| 3.14k|uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept { 3140| 3.14k| int shl = leading_zeroes(r0); 3141| 3.14k| if (shl == 0) { ------------------ | Branch (3141:7): [True: 333, False: 2.80k] ------------------ 3142| 333| truncated = r1 != 0; 3143| 333| return r0; 3144| 2.80k| } else { 3145| 2.80k| int shr = 64 - shl; 3146| 2.80k| truncated = (r1 << shl) != 0; 3147| 2.80k| return (r0 << shl) | (r1 >> shr); 3148| 2.80k| } 3149| 3.14k|} _ZNK3glz10fast_float8stackvecILt62EE7nonzeroEm: 3107| 3.14k| GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept { 3108| 3.34k| while (index < len()) { ------------------ | Branch (3108:12): [True: 2.15k, False: 1.18k] ------------------ 3109| 2.15k| if (rindex(index) != 0) { ------------------ | Branch (3109:11): [True: 1.95k, False: 199] ------------------ 3110| 1.95k| return true; 3111| 1.95k| } 3112| 199| index++; 3113| 199| } 3114| 1.18k| return false; 3115| 3.14k| } _ZNK3glz10fast_float6bigint10bit_lengthEv: 3547| 3.82k| GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept { 3548| 3.82k| int lz = ctlz(); 3549| 3.82k| return int(limb_bits * vec.len()) - lz; 3550| 3.82k| } _ZNK3glz10fast_float6bigint4ctlzEv: 3532| 3.82k| GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept { 3533| 3.82k| if (vec.is_empty()) { ------------------ | Branch (3533:9): [True: 0, False: 3.82k] ------------------ 3534| 0| return 0; 3535| 3.82k| } else { 3536| 3.82k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3537| 3.82k| 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| 3.82k| } 3544| 3.82k| } _ZN3glz10fast_float5roundIdZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiEUlRS3_iE_EEvS6_T0_: 3707| 3.82k| callback cb) noexcept { 3708| 3.82k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 3.82k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 0, False: 3.82k] ------------------ 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| 3.82k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 3.82k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 194, False: 3.63k] ------------------ 3726| 3.82k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 194| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 194| am.power2++; 3729| 194| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 3.82k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 3.82k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 3.82k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 3.82k|} _ZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_i: 3951| 3.82k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 3.82k| round_nearest_tie_even( 3953| 3.82k| a, shift, 3954| 3.82k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.82k| return is_above || (is_halfway && truncated) || 3956| 3.82k| (is_odd && is_halfway); 3957| 3.82k| }); 3958| 3.82k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS3_iE_clES6_iEUlbbbE_EEvS6_iT_: 3742| 3.82k| callback cb) noexcept { 3743| 3.82k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 3.82k] ------------------ 3744| 3.82k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 3.82k] ------------------ 3745| 3.82k| uint64_t truncated_bits = am.mantissa & mask; 3746| 3.82k| bool is_above = truncated_bits > halfway; 3747| 3.82k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 3.82k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 3.82k] ------------------ 3751| 0| am.mantissa = 0; 3752| 3.82k| } else { 3753| 3.82k| am.mantissa >>= shift; 3754| 3.82k| } 3755| 3.82k| am.power2 += shift; 3756| | 3757| 3.82k| bool is_odd = (am.mantissa & 1) == 1; 3758| 3.82k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 3.82k|} _ZZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_iENKUlbbbE_clEbbb: 3954| 3.82k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.82k| return is_above || (is_halfway && truncated) || ------------------ | Branch (3955:18): [True: 641, False: 3.18k] | Branch (3955:31): [True: 797, False: 2.39k] | Branch (3955:45): [True: 566, False: 231] ------------------ 3956| 2.62k| (is_odd && is_halfway); ------------------ | Branch (3956:19): [True: 516, False: 2.10k] | Branch (3956:29): [True: 8, False: 508] ------------------ 3957| 3.82k| }); _ZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_i: 3970| 10.0k| bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept { 3971| 10.0k| bigint &real_digits = bigmant; 3972| 10.0k| int32_t real_exp = exponent; 3973| | 3974| | // get the value of `b`, rounded down, and get a bigint representation of b+h 3975| 10.0k| adjusted_mantissa am_b = am; 3976| | // gcc7 buf: use a lambda to remove the noexcept qualifier bug with 3977| | // -Wnoexcept-type. 3978| 10.0k| round(am_b, 3979| 10.0k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); 3980| 10.0k| T b; 3981| 10.0k| to_float(false, am_b, b); 3982| 10.0k| adjusted_mantissa theor = to_extended_halfway(b); 3983| 10.0k| bigint theor_digits(theor.mantissa); 3984| 10.0k| int32_t theor_exp = theor.power2; 3985| | 3986| | // scale real digits and theor digits to be same power. 3987| 10.0k| int32_t pow2_exp = theor_exp - real_exp; 3988| 10.0k| uint32_t pow5_exp = uint32_t(-real_exp); 3989| 10.0k| if (pow5_exp != 0) { ------------------ | Branch (3989:7): [True: 10.0k, False: 0] ------------------ 3990| 10.0k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp)); ------------------ | | 344| 10.0k| { ((void)(x)); } ------------------ 3991| 10.0k| } 3992| 10.0k| if (pow2_exp > 0) { ------------------ | Branch (3992:7): [True: 7.11k, False: 2.91k] ------------------ 3993| 7.11k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp))); ------------------ | | 344| 7.11k| { ((void)(x)); } ------------------ 3994| 7.11k| } else if (pow2_exp < 0) { ------------------ | Branch (3994:14): [True: 2.71k, False: 196] ------------------ 3995| 2.71k| GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp))); ------------------ | | 344| 2.71k| { ((void)(x)); } ------------------ 3996| 2.71k| } 3997| | 3998| | // compare digits, and use it to director rounding 3999| 10.0k| int ord = real_digits.compare(theor_digits); 4000| 10.0k| adjusted_mantissa answer = am; 4001| 10.0k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 10.0k| round_nearest_tie_even( 4003| 10.0k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 10.0k| (void)_; // not needed, since we've done our comparison 4005| 10.0k| (void)__; // not needed, since we've done our comparison 4006| 10.0k| if (ord > 0) { 4007| 10.0k| return true; 4008| 10.0k| } else if (ord < 0) { 4009| 10.0k| return false; 4010| 10.0k| } else { 4011| 10.0k| return is_odd; 4012| 10.0k| } 4013| 10.0k| }); 4014| 10.0k| }); 4015| | 4016| 10.0k| return answer; 4017| 10.0k|} _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE_EEvS6_T0_: 3707| 10.0k| callback cb) noexcept { 3708| 10.0k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 10.0k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 704, False: 9.32k] ------------------ 3710| | // have a denormal float 3711| 704| int32_t shift = -am.power2 + 1; 3712| 704| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 704| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 704, False: 0] ------------------ 3715| 704| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 704| ? 0 3717| 704| : 1; 3718| 704| return; 3719| 704| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 9.32k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 9.32k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 0, False: 9.32k] ------------------ 3726| 9.32k| (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| 9.32k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 9.32k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 9.32k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 9.32k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE_clES5_i: 3979| 10.0k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); _ZN3glz10fast_float10round_downERNS0_17adjusted_mantissaEi: 3762| 10.0k|round_down(adjusted_mantissa &am, int32_t shift) noexcept { 3763| 10.0k| if (shift == 64) { ------------------ | Branch (3763:7): [True: 0, False: 10.0k] ------------------ 3764| 0| am.mantissa = 0; 3765| 10.0k| } else { 3766| 10.0k| am.mantissa >>= shift; 3767| 10.0k| } 3768| 10.0k| am.power2 += shift; 3769| 10.0k|} _ZN3glz10fast_float19to_extended_halfwayIdEENS0_17adjusted_mantissaET_: 3696| 10.0k|to_extended_halfway(T value) noexcept { 3697| 10.0k| adjusted_mantissa am = to_extended(value); 3698| 10.0k| am.mantissa <<= 1; 3699| 10.0k| am.mantissa += 1; 3700| 10.0k| am.power2 -= 1; 3701| 10.0k| return am; 3702| 10.0k|} _ZN3glz10fast_float11to_extendedIdEENS0_17adjusted_mantissaET_: 3661| 10.0k|to_extended(T value) noexcept { 3662| 10.0k| using equiv_uint = equiv_uint_t; 3663| 10.0k| constexpr equiv_uint exponent_mask = binary_format::exponent_mask(); 3664| 10.0k| constexpr equiv_uint mantissa_mask = binary_format::mantissa_mask(); 3665| 10.0k| constexpr equiv_uint hidden_bit_mask = binary_format::hidden_bit_mask(); 3666| | 3667| 10.0k| adjusted_mantissa am; 3668| 10.0k| int32_t bias = binary_format::mantissa_explicit_bits() - 3669| 10.0k| binary_format::minimum_exponent(); 3670| 10.0k| equiv_uint bits; 3671| 10.0k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 3672| 10.0k| bits = std::bit_cast(value); 3673| |#else 3674| | ::memcpy(&bits, &value, sizeof(T)); 3675| |#endif 3676| 10.0k| if ((bits & exponent_mask) == 0) { ------------------ | Branch (3676:7): [True: 704, False: 9.32k] ------------------ 3677| | // denormal 3678| 704| am.power2 = 1 - bias; 3679| 704| am.mantissa = bits & mantissa_mask; 3680| 9.32k| } else { 3681| | // normal 3682| 9.32k| am.power2 = int32_t((bits & exponent_mask) >> 3683| 9.32k| binary_format::mantissa_explicit_bits()); 3684| 9.32k| am.power2 -= bias; 3685| 9.32k| am.mantissa = (bits & mantissa_mask) | hidden_bit_mask; 3686| 9.32k| } 3687| | 3688| 10.0k| return am; 3689| 10.0k|} _ZN3glz10fast_float6bigintC2Em: 3406| 10.0k| GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() { 3407| 10.0k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3408| 10.0k| vec.push_unchecked(value); 3409| |#else 3410| | vec.push_unchecked(uint32_t(value)); 3411| | vec.push_unchecked(uint32_t(value >> 32)); 3412| |#endif 3413| 10.0k| vec.normalize(); 3414| 10.0k| } _ZNK3glz10fast_float6bigint7compareERKS1_: 3451| 10.0k| GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept { 3452| 10.0k| if (vec.len() > other.vec.len()) { ------------------ | Branch (3452:9): [True: 0, False: 10.0k] ------------------ 3453| 0| return 1; 3454| 10.0k| } else if (vec.len() < other.vec.len()) { ------------------ | Branch (3454:16): [True: 0, False: 10.0k] ------------------ 3455| 0| return -1; 3456| 10.0k| } else { 3457| 62.7k| for (size_t index = vec.len(); index > 0; index--) { ------------------ | Branch (3457:38): [True: 62.0k, False: 671] ------------------ 3458| 62.0k| limb xi = vec[index - 1]; 3459| 62.0k| limb yi = other.vec[index - 1]; 3460| 62.0k| if (xi > yi) { ------------------ | Branch (3460:13): [True: 5.08k, False: 57.0k] ------------------ 3461| 5.08k| return 1; 3462| 57.0k| } else if (xi < yi) { ------------------ | Branch (3462:20): [True: 4.26k, False: 52.7k] ------------------ 3463| 4.26k| return -1; 3464| 4.26k| } 3465| 62.0k| } 3466| 671| return 0; 3467| 10.0k| } 3468| 10.0k| } _ZNK3glz10fast_float8stackvecILt62EEixEm: 3022| 124k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept { 3023| 124k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 124k| { ((void)(x)); } ------------------ 3024| 124k| return data[index]; 3025| 124k| } _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE0_EEvS6_T0_: 3707| 10.0k| callback cb) noexcept { 3708| 10.0k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 10.0k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 704, False: 9.32k] ------------------ 3710| | // have a denormal float 3711| 704| int32_t shift = -am.power2 + 1; 3712| 704| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 704| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 704, False: 0] ------------------ 3715| 704| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 704| ? 0 3717| 704| : 1; 3718| 704| return; 3719| 704| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 9.32k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 9.32k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 258, False: 9.06k] ------------------ 3726| 9.32k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 258| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 258| am.power2++; 3729| 258| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 9.32k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 9.32k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 9.32k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 9.32k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_i: 4001| 10.0k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 10.0k| round_nearest_tie_even( 4003| 10.0k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 10.0k| (void)_; // not needed, since we've done our comparison 4005| 10.0k| (void)__; // not needed, since we've done our comparison 4006| 10.0k| if (ord > 0) { 4007| 10.0k| return true; 4008| 10.0k| } else if (ord < 0) { 4009| 10.0k| return false; 4010| 10.0k| } else { 4011| 10.0k| return is_odd; 4012| 10.0k| } 4013| 10.0k| }); 4014| 10.0k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iENKUlRS3_iE0_clES6_iEUlbbbE_EEvS6_iT_: 3742| 10.0k| callback cb) noexcept { 3743| 10.0k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 10.0k] ------------------ 3744| 10.0k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 10.0k] ------------------ 3745| 10.0k| uint64_t truncated_bits = am.mantissa & mask; 3746| 10.0k| bool is_above = truncated_bits > halfway; 3747| 10.0k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 10.0k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 10.0k] ------------------ 3751| 0| am.mantissa = 0; 3752| 10.0k| } else { 3753| 10.0k| am.mantissa >>= shift; 3754| 10.0k| } 3755| 10.0k| am.power2 += shift; 3756| | 3757| 10.0k| bool is_odd = (am.mantissa & 1) == 1; 3758| 10.0k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 10.0k|} _ZZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_iENKUlbbbE_clEbbb: 4003| 10.0k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 10.0k| (void)_; // not needed, since we've done our comparison 4005| 10.0k| (void)__; // not needed, since we've done our comparison 4006| 10.0k| if (ord > 0) { ------------------ | Branch (4006:15): [True: 5.08k, False: 4.93k] ------------------ 4007| 5.08k| return true; 4008| 5.08k| } else if (ord < 0) { ------------------ | Branch (4008:22): [True: 4.26k, False: 671] ------------------ 4009| 4.26k| return false; 4010| 4.26k| } else { 4011| 671| return is_odd; 4012| 671| } 4013| 10.0k| }); _ZN3glz10fast_float8to_floatIdEEvbNS0_17adjusted_mantissaERT_: 1131| 52.8k|to_float(bool negative, adjusted_mantissa am, T &value) { 1132| 52.8k| using equiv_uint = equiv_uint_t; 1133| 52.8k| equiv_uint word = equiv_uint(am.mantissa); 1134| 52.8k| word = equiv_uint(word | equiv_uint(am.power2) 1135| 52.8k| << binary_format::mantissa_explicit_bits()); 1136| 52.8k| word = 1137| 52.8k| equiv_uint(word | equiv_uint(negative) << binary_format::sign_index()); 1138| 52.8k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 1139| 52.8k| value = std::bit_cast(word); 1140| |#else 1141| | ::memcpy(&value, &word, sizeof(T)); 1142| |#endif 1143| 52.8k|} _ZN3glz10fast_float13binary_formatIdE10sign_indexEv: 758| 52.8k|template <> inline constexpr int binary_format::sign_index() { 759| 52.8k| return 63; 760| 52.8k|} _ZN3glz10fast_float13binary_formatIdE14infinite_powerEv: 750| 110k|template <> inline constexpr int binary_format::infinite_power() { 751| 110k| return 0x7FF; 752| 110k|} jsonrpc_registry.cpp:_ZN3glz8for_eachILm4EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz10member_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 27| 79.7k| { 28| 79.7k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| 79.7k| else if constexpr (N == 4) { 44| 79.7k| lambda.template operator()<0>(); 45| 79.7k| lambda.template operator()<1>(); 46| 79.7k| lambda.template operator()<2>(); 47| 79.7k| lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 79.7k| } 55| 79.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_: 27| 129| { 28| 129| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 129| else if constexpr (N == 2) { 35| 129| lambda.template operator()<0>(); 36| 129| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 129| } 55| 129| } _ZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN12jsonrpc_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m: 86| 33.5k| { 87| 33.5k| if constexpr (N > 0) { 88| 33.5k| assert(index < N && "glz::visit index out of range"); ------------------ | Branch (88:10): [True: 33.5k, False: 0] | Branch (88:10): [True: 33.5k, Folded] | Branch (88:10): [True: 33.5k, False: 0] ------------------ 89| | // Explicit sizes for small N to help the compiler and make debugging easier 90| | if constexpr (N == 1) { 91| | (void)index; 92| | (void)(lambda.template operator()<0>()); 93| | } 94| | else if constexpr (N == 2) { 95| | switch (index) { 96| | case 0: 97| | lambda.template operator()<0>(); 98| | break; 99| | case 1: 100| | lambda.template operator()<1>(); 101| | break; 102| | default: 103| | std::unreachable(); 104| | } 105| | } 106| | else if constexpr (N == 3) { 107| | switch (index) { 108| | case 0: 109| | lambda.template operator()<0>(); 110| | break; 111| | case 1: 112| | lambda.template operator()<1>(); 113| | break; 114| | case 2: 115| | lambda.template operator()<2>(); 116| | break; 117| | default: 118| | std::unreachable(); 119| | } 120| | } 121| | else if constexpr (N == 4) { 122| | switch (index) { 123| | case 0: 124| | lambda.template operator()<0>(); 125| | break; 126| | case 1: 127| | lambda.template operator()<1>(); 128| | break; 129| | case 2: 130| | lambda.template operator()<2>(); 131| | break; 132| | case 3: 133| | lambda.template operator()<3>(); 134| | break; 135| | default: 136| | std::unreachable(); 137| | } 138| | } 139| | else if constexpr (N == 5) { 140| | switch (index) { 141| | case 0: 142| | lambda.template operator()<0>(); 143| | break; 144| | case 1: 145| | lambda.template operator()<1>(); 146| | break; 147| | case 2: 148| | lambda.template operator()<2>(); 149| | break; 150| | case 3: 151| | lambda.template operator()<3>(); 152| | break; 153| | case 4: 154| | lambda.template operator()<4>(); 155| | break; 156| | default: 157| | std::unreachable(); 158| | } 159| | } 160| | else if constexpr (N == 6) { 161| | switch (index) { 162| | case 0: 163| | lambda.template operator()<0>(); 164| | break; 165| | case 1: 166| | lambda.template operator()<1>(); 167| | break; 168| | case 2: 169| | lambda.template operator()<2>(); 170| | break; 171| | case 3: 172| | lambda.template operator()<3>(); 173| | break; 174| | case 4: 175| | lambda.template operator()<4>(); 176| | break; 177| | case 5: 178| | lambda.template operator()<5>(); 179| | break; 180| | default: 181| | std::unreachable(); 182| | } 183| | } 184| | else if constexpr (N == 7) { 185| | switch (index) { 186| | case 0: 187| | lambda.template operator()<0>(); 188| | break; 189| | case 1: 190| | lambda.template operator()<1>(); 191| | break; 192| | case 2: 193| | lambda.template operator()<2>(); 194| | break; 195| | case 3: 196| | lambda.template operator()<3>(); 197| | break; 198| | case 4: 199| | lambda.template operator()<4>(); 200| | break; 201| | case 5: 202| | lambda.template operator()<5>(); 203| | break; 204| | case 6: 205| | lambda.template operator()<6>(); 206| | break; 207| | default: 208| | std::unreachable(); 209| | } 210| | } 211| | else if constexpr (N == 8) { 212| | switch (index) { 213| | case 0: 214| | lambda.template operator()<0>(); 215| | break; 216| | case 1: 217| | lambda.template operator()<1>(); 218| | break; 219| | case 2: 220| | lambda.template operator()<2>(); 221| | break; 222| | case 3: 223| | lambda.template operator()<3>(); 224| | break; 225| | case 4: 226| | lambda.template operator()<4>(); 227| | break; 228| | case 5: 229| | lambda.template operator()<5>(); 230| | break; 231| | case 6: 232| | lambda.template operator()<6>(); 233| | break; 234| | case 7: 235| | lambda.template operator()<7>(); 236| | break; 237| | default: 238| | std::unreachable(); 239| | } 240| | } 241| | else if constexpr (N == 9) { 242| | switch (index) { 243| | case 0: 244| | lambda.template operator()<0>(); 245| | break; 246| | case 1: 247| | lambda.template operator()<1>(); 248| | break; 249| | case 2: 250| | lambda.template operator()<2>(); 251| | break; 252| | case 3: 253| | lambda.template operator()<3>(); 254| | break; 255| | case 4: 256| | lambda.template operator()<4>(); 257| | break; 258| | case 5: 259| | lambda.template operator()<5>(); 260| | break; 261| | case 6: 262| | lambda.template operator()<6>(); 263| | break; 264| | case 7: 265| | lambda.template operator()<7>(); 266| | break; 267| | case 8: 268| | lambda.template operator()<8>(); 269| | break; 270| | default: 271| | std::unreachable(); 272| | } 273| | } 274| | else if constexpr (N == 10) { 275| | switch (index) { 276| | case 0: 277| | lambda.template operator()<0>(); 278| | break; 279| | case 1: 280| | lambda.template operator()<1>(); 281| | break; 282| | case 2: 283| | lambda.template operator()<2>(); 284| | break; 285| | case 3: 286| | lambda.template operator()<3>(); 287| | break; 288| | case 4: 289| | lambda.template operator()<4>(); 290| | break; 291| | case 5: 292| | lambda.template operator()<5>(); 293| | break; 294| | case 6: 295| | lambda.template operator()<6>(); 296| | break; 297| | case 7: 298| | lambda.template operator()<7>(); 299| | break; 300| | case 8: 301| | lambda.template operator()<8>(); 302| | break; 303| | case 9: 304| | lambda.template operator()<9>(); 305| | break; 306| | default: 307| | std::unreachable(); 308| | } 309| | } 310| 33.5k| else { 311| |#ifdef _MSC_VER 312| | using Lambda = std::decay_t; 313| | static const auto jump_table = [](std::index_sequence) { 314| | return std::array{make_jump_function()...}; 315| | }(std::make_index_sequence{}); 316| |#else 317| 33.5k| static constexpr auto jump_table = [](std::index_sequence) { 318| 33.5k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; 319| 33.5k| }(std::make_index_sequence{}); 320| 33.5k|#endif 321| | 322| 33.5k|#if defined(__clang_major__) && (__clang_major__ >= 19) 323| 33.5k| [[assume(index < N)]]; 324| 33.5k|#endif 325| 33.5k| jump_table[index](lambda); 326| | 327| | // This code runs significantly slower on Clang 328| | // Simple tests with assembly show that this should be faster, 329| | // but full Glaze assembly need to be looked into 330| | /*[&, index](std::index_sequence) { 331| | (void)((index == I ? lambda.template operator()() : void()), ...); 332| | }(std::make_index_sequence{});*/ 333| 33.5k| } 334| 33.5k| } 335| 33.5k| } _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_: 318| 17.4k| 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_: 318| 139| 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_: 318| 908| 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_: 318| 731| 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_: 318| 8.21k| 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_: 318| 1.22k| 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_: 318| 1.41k| 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_: 318| 1.54k| 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_: 27| 1.80k| { 28| 1.80k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 1.80k| else if constexpr (N == 2) { 35| 1.80k| lambda.template operator()<0>(); 36| 1.80k| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 1.80k| } 55| 1.80k| } _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_: 318| 508| 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_: 318| 434| 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_: 318| 444| 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_: 318| 328| 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_: 318| 226| 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_: 27| 60| { 28| 60| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| 60| else { 50| 60| [&](std::index_sequence) { 51| 60| (void)(lambda.template operator()(), ...); 52| 60| }(std::make_index_sequence{}); 53| 60| } 54| 60| } 55| 60| } _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_: 50| 60| [&](std::index_sequence) { 51| 60| (void)(lambda.template operator()(), ...); 52| 60| }(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_: 27| 319| { 28| 319| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 319| else if constexpr (N == 2) { 35| 319| lambda.template operator()<0>(); 36| 319| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 319| } 55| 319| } _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_: 27| 101| { 28| 101| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 101| else if constexpr (N == 2) { 35| 101| lambda.template operator()<0>(); 36| 101| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 101| } 55| 101| } jsonrpc_registry.cpp:_ZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30200EE16register_membersIL_ZNS_6detailL10empty_pathEEN12jsonrpc_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 27| 79.7k| { 28| 79.7k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| 79.7k| else { 50| 79.7k| [&](std::index_sequence) { 51| 79.7k| (void)(lambda.template operator()(), ...); 52| 79.7k| }(std::make_index_sequence{}); 53| 79.7k| } 54| 79.7k| } 55| 79.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_: 50| 79.7k| [&](std::index_sequence) { 51| 79.7k| (void)(lambda.template operator()(), ...); 52| 79.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_: 27| 79.7k| { 28| 79.7k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 79.7k| else if constexpr (N == 2) { 35| 79.7k| lambda.template operator()<0>(); 36| 79.7k| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 79.7k| } 55| 79.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_: 27| 79.7k| { 28| 79.7k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| 79.7k| else if constexpr (N == 2) { 35| 79.7k| lambda.template operator()<0>(); 36| 79.7k| lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 79.7k| } 55| 79.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: 86| 278k| { 87| 278k| if constexpr (N > 0) { 88| 278k| assert(index < N && "glz::visit index out of range"); ------------------ | Branch (88:10): [True: 278k, False: 0] | Branch (88:10): [True: 278k, Folded] | Branch (88:10): [True: 278k, False: 0] ------------------ 89| | // Explicit sizes for small N to help the compiler and make debugging easier 90| | if constexpr (N == 1) { 91| | (void)index; 92| | (void)(lambda.template operator()<0>()); 93| | } 94| | else if constexpr (N == 2) { 95| | switch (index) { 96| | case 0: 97| | lambda.template operator()<0>(); 98| | break; 99| | case 1: 100| | lambda.template operator()<1>(); 101| | break; 102| | default: 103| | std::unreachable(); 104| | } 105| | } 106| | else if constexpr (N == 3) { 107| | switch (index) { 108| | case 0: 109| | lambda.template operator()<0>(); 110| | break; 111| | case 1: 112| | lambda.template operator()<1>(); 113| | break; 114| | case 2: 115| | lambda.template operator()<2>(); 116| | break; 117| | default: 118| | std::unreachable(); 119| | } 120| | } 121| 278k| else if constexpr (N == 4) { 122| 278k| switch (index) { 123| 75.9k| case 0: ------------------ | Branch (123:13): [True: 75.9k, False: 202k] ------------------ 124| 75.9k| lambda.template operator()<0>(); 125| 75.9k| break; 126| 65.9k| case 1: ------------------ | Branch (126:13): [True: 65.9k, False: 212k] ------------------ 127| 65.9k| lambda.template operator()<1>(); 128| 65.9k| break; 129| 46.9k| case 2: ------------------ | Branch (129:13): [True: 46.9k, False: 231k] ------------------ 130| 46.9k| lambda.template operator()<2>(); 131| 46.9k| break; 132| 89.3k| case 3: ------------------ | Branch (132:13): [True: 89.3k, False: 188k] ------------------ 133| 89.3k| lambda.template operator()<3>(); 134| 89.3k| break; 135| 0| default: ------------------ | Branch (135:13): [True: 0, False: 278k] ------------------ 136| 0| std::unreachable(); 137| 278k| } 138| | } 139| | else if constexpr (N == 5) { 140| | switch (index) { 141| | case 0: 142| | lambda.template operator()<0>(); 143| | break; 144| | case 1: 145| | lambda.template operator()<1>(); 146| | break; 147| | case 2: 148| | lambda.template operator()<2>(); 149| | break; 150| | case 3: 151| | lambda.template operator()<3>(); 152| | break; 153| | case 4: 154| | lambda.template operator()<4>(); 155| | break; 156| | default: 157| | std::unreachable(); 158| | } 159| | } 160| | else if constexpr (N == 6) { 161| | switch (index) { 162| | case 0: 163| | lambda.template operator()<0>(); 164| | break; 165| | case 1: 166| | lambda.template operator()<1>(); 167| | break; 168| | case 2: 169| | lambda.template operator()<2>(); 170| | break; 171| | case 3: 172| | lambda.template operator()<3>(); 173| | break; 174| | case 4: 175| | lambda.template operator()<4>(); 176| | break; 177| | case 5: 178| | lambda.template operator()<5>(); 179| | break; 180| | default: 181| | std::unreachable(); 182| | } 183| | } 184| | else if constexpr (N == 7) { 185| | switch (index) { 186| | case 0: 187| | lambda.template operator()<0>(); 188| | break; 189| | case 1: 190| | lambda.template operator()<1>(); 191| | break; 192| | case 2: 193| | lambda.template operator()<2>(); 194| | break; 195| | case 3: 196| | lambda.template operator()<3>(); 197| | break; 198| | case 4: 199| | lambda.template operator()<4>(); 200| | break; 201| | case 5: 202| | lambda.template operator()<5>(); 203| | break; 204| | case 6: 205| | lambda.template operator()<6>(); 206| | break; 207| | default: 208| | std::unreachable(); 209| | } 210| | } 211| | else if constexpr (N == 8) { 212| | switch (index) { 213| | case 0: 214| | lambda.template operator()<0>(); 215| | break; 216| | case 1: 217| | lambda.template operator()<1>(); 218| | break; 219| | case 2: 220| | lambda.template operator()<2>(); 221| | break; 222| | case 3: 223| | lambda.template operator()<3>(); 224| | break; 225| | case 4: 226| | lambda.template operator()<4>(); 227| | break; 228| | case 5: 229| | lambda.template operator()<5>(); 230| | break; 231| | case 6: 232| | lambda.template operator()<6>(); 233| | break; 234| | case 7: 235| | lambda.template operator()<7>(); 236| | break; 237| | default: 238| | std::unreachable(); 239| | } 240| | } 241| | else if constexpr (N == 9) { 242| | switch (index) { 243| | case 0: 244| | lambda.template operator()<0>(); 245| | break; 246| | case 1: 247| | lambda.template operator()<1>(); 248| | break; 249| | case 2: 250| | lambda.template operator()<2>(); 251| | break; 252| | case 3: 253| | lambda.template operator()<3>(); 254| | break; 255| | case 4: 256| | lambda.template operator()<4>(); 257| | break; 258| | case 5: 259| | lambda.template operator()<5>(); 260| | break; 261| | case 6: 262| | lambda.template operator()<6>(); 263| | break; 264| | case 7: 265| | lambda.template operator()<7>(); 266| | break; 267| | case 8: 268| | lambda.template operator()<8>(); 269| | break; 270| | default: 271| | std::unreachable(); 272| | } 273| | } 274| | else if constexpr (N == 10) { 275| | switch (index) { 276| | case 0: 277| | lambda.template operator()<0>(); 278| | break; 279| | case 1: 280| | lambda.template operator()<1>(); 281| | break; 282| | case 2: 283| | lambda.template operator()<2>(); 284| | break; 285| | case 3: 286| | lambda.template operator()<3>(); 287| | break; 288| | case 4: 289| | lambda.template operator()<4>(); 290| | break; 291| | case 5: 292| | lambda.template operator()<5>(); 293| | break; 294| | case 6: 295| | lambda.template operator()<6>(); 296| | break; 297| | case 7: 298| | lambda.template operator()<7>(); 299| | break; 300| | case 8: 301| | lambda.template operator()<8>(); 302| | break; 303| | case 9: 304| | lambda.template operator()<9>(); 305| | break; 306| | default: 307| | std::unreachable(); 308| | } 309| | } 310| | else { 311| |#ifdef _MSC_VER 312| | using Lambda = std::decay_t; 313| | static const auto jump_table = [](std::index_sequence) { 314| | return std::array{make_jump_function()...}; 315| | }(std::make_index_sequence{}); 316| |#else 317| | static constexpr auto jump_table = [](std::index_sequence) { 318| | return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; 319| | }(std::make_index_sequence{}); 320| |#endif 321| | 322| |#if defined(__clang_major__) && (__clang_major__ >= 19) 323| | [[assume(index < N)]]; 324| |#endif 325| | jump_table[index](lambda); 326| | 327| | // This code runs significantly slower on Clang 328| | // Simple tests with assembly show that this should be faster, 329| | // but full Glaze assembly need to be looked into 330| | /*[&, index](std::index_sequence) { 331| | (void)((index == I ? lambda.template operator()() : void()), ...); 332| | }(std::make_index_sequence{});*/ 333| | } 334| 278k| } 335| 278k| } _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_: 27| 9.07k| { 28| 9.07k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| 9.07k| else if constexpr (N == 3) { 39| 9.07k| lambda.template operator()<0>(); 40| 9.07k| lambda.template operator()<1>(); 41| 9.07k| lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 9.07k| } 55| 9.07k| } _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_: 27| 76.4k| { 28| 76.4k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| 76.4k| else if constexpr (N == 3) { 39| 76.4k| lambda.template operator()<0>(); 40| 76.4k| lambda.template operator()<1>(); 41| 76.4k| lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 76.4k| } 55| 76.4k| } _ZN3glz8for_eachILm1EZNS_13get_view_jsonITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc47ELc105ELc100EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10contiguousERNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEDaOT1_EUlTnmvE_EEvOT0_: 27| 95.4k| { 28| 95.4k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| 95.4k| if constexpr (N == 1) { 32| 95.4k| lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| | else { 50| | [&](std::index_sequence) { 51| | (void)(lambda.template operator()(), ...); 52| | }(std::make_index_sequence{}); 53| | } 54| 95.4k| } 55| 95.4k| } _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_: 27| 20.5k| { 28| 20.5k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| 20.5k| else { 50| 20.5k| [&](std::index_sequence) { 51| 20.5k| (void)(lambda.template operator()(), ...); 52| 20.5k| }(std::make_index_sequence{}); 53| 20.5k| } 54| 20.5k| } 55| 20.5k| } _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_: 50| 20.5k| [&](std::index_sequence) { 51| 20.5k| (void)(lambda.template operator()(), ...); 52| 20.5k| }(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_: 27| 1.65M| { 28| 1.65M| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| 1.65M| else { 50| 1.65M| [&](std::index_sequence) { 51| 1.65M| (void)(lambda.template operator()(), ...); 52| 1.65M| }(std::make_index_sequence{}); 53| 1.65M| } 54| 1.65M| } 55| 1.65M| } _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_: 50| 1.65M| [&](std::index_sequence) { 51| 1.65M| (void)(lambda.template operator()(), ...); 52| 1.65M| }(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_: 27| 571k| { 28| 571k| if constexpr (N > 0) { 29| | // Explicit sizes for small N to help the compiler and make debugging easier 30| | // These generate less assembly with O0, but make no difference for higher optimization 31| | if constexpr (N == 1) { 32| | lambda.template operator()<0>(); 33| | } 34| | else if constexpr (N == 2) { 35| | lambda.template operator()<0>(); 36| | lambda.template operator()<1>(); 37| | } 38| | else if constexpr (N == 3) { 39| | lambda.template operator()<0>(); 40| | lambda.template operator()<1>(); 41| | lambda.template operator()<2>(); 42| | } 43| | else if constexpr (N == 4) { 44| | lambda.template operator()<0>(); 45| | lambda.template operator()<1>(); 46| | lambda.template operator()<2>(); 47| | lambda.template operator()<3>(); 48| | } 49| 571k| else { 50| 571k| [&](std::index_sequence) { 51| 571k| (void)(lambda.template operator()(), ...); 52| 571k| }(std::make_index_sequence{}); 53| 571k| } 54| 571k| } 55| 571k| } _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_: 50| 571k| [&](std::index_sequence) { 51| 571k| (void)(lambda.template operator()(), ...); 52| 571k| }(std::make_index_sequence{}); _ZN3glz10from_charsILb0EdcEENS_10fast_float19from_chars_result_tIT1_EEPKS3_S6_RT0_: 235| 1.28M| { 236| 1.28M| using namespace glz::fast_float; 237| 1.28M| static_assert(is_supported_float_type(), "only some floating-point types are supported"); 238| 1.28M| static_assert(is_supported_char_type(), "only char, wchar_t, char16_t and char32_t are supported"); 239| | 240| 1.28M| parsed_number_string_t pns = glz::parse_number_string(first, last); 241| 1.28M| if (!pns.valid) [[unlikely]] { ------------------ | Branch (241:11): [True: 1.48k, False: 1.28M] ------------------ 242| 1.48k| return {.ptr = first, .ec = std::errc::invalid_argument}; 243| 1.48k| } 244| | 245| 1.28M| return from_chars_advanced(pns, value); 246| 1.28M| } _ZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_: 18| 1.28M| { 19| 1.28M| using namespace glz::fast_float; 20| 1.28M| static constexpr UC decimal_point = '.'; 21| | 22| 1.28M| parsed_number_string_t answer; 23| 1.28M| answer.valid = false; 24| 1.28M| answer.too_many_digits = false; 25| 1.28M| answer.negative = (*p == UC('-')); 26| 1.28M| if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here ------------------ | Branch (26:11): [True: 1.04M, False: 239k] ------------------ 27| 1.04M| ++p; 28| | 29| 1.04M| if constexpr (not null_terminated) { 30| 1.04M| if (p == pend) [[unlikely]] { ------------------ | Branch (30:17): [True: 4, False: 1.04M] ------------------ 31| 4| return answer; 32| 4| } 33| 1.04M| } 34| | 35| 1.04M| if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer ------------------ | Branch (35:14): [True: 44, False: 1.04M] ------------------ 36| 44| return answer; 37| 44| } 38| 1.04M| } 39| 1.28M| UC const* const start_digits = p; 40| | 41| 1.28M| uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad) 42| | 43| 1.28M| 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| 1.28M| else { 53| 8.24M| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (53:17): [True: 8.24M, False: 648] | Branch (53:32): [True: 6.96M, False: 1.28M] ------------------ 54| | // a multiplication by 10 is cheaper than an arbitrary integer 55| | // multiplication 56| 6.96M| i = 10 * i + digit; // might overflow, we will handle the overflow later 57| 6.96M| ++p; 58| 6.96M| } 59| 1.28M| } 60| | 61| 1.28M| UC const* const end_of_integer_part = p; 62| 1.28M| int64_t digit_count = int64_t(end_of_integer_part - start_digits); 63| 1.28M| 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| 1.28M| if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) { ------------------ | Branch (66:11): [True: 1.30k, False: 1.28M] | Branch (66:32): [True: 66.7k, False: 1.21M] | Branch (66:62): [True: 42, False: 66.6k] ------------------ 67| 1.33k| return answer; 68| 1.33k| } 69| | 70| 1.28M| int64_t exponent = 0; 71| 1.28M| const bool has_decimal_point = [&] { 72| 1.28M| if constexpr (null_terminated) { 73| 1.28M| return (*p == decimal_point); 74| 1.28M| } 75| 1.28M| else { 76| 1.28M| return (p != pend) && (*p == decimal_point); 77| 1.28M| } 78| 1.28M| }(); 79| 1.28M| if (has_decimal_point) { ------------------ | Branch (79:11): [True: 21.7k, False: 1.26M] ------------------ 80| 21.7k| ++p; 81| 21.7k| 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| 21.7k| 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| 21.7k| else { 93| 95.7k| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (93:20): [True: 94.6k, False: 1.06k] | Branch (93:35): [True: 74.0k, False: 20.6k] ------------------ 94| 74.0k| ++p; 95| 74.0k| i = i * 10 + digit; // in rare cases, this will overflow, but that's ok 96| 74.0k| } 97| 21.7k| } 98| 21.7k| exponent = before - p; 99| 21.7k| answer.fraction = glz::fast_float::span(before, size_t(p - before)); 100| 21.7k| digit_count -= exponent; 101| 21.7k| } 102| | // at least 1 digit in fractional part 103| 1.28M| if (has_decimal_point && exponent == 0) { ------------------ | Branch (103:11): [True: 21.7k, False: 1.26M] | Branch (103:32): [True: 25, False: 21.7k] ------------------ 104| 25| return answer; 105| 25| } 106| | 107| 1.28M| int64_t exp_number = 0; // explicit exponential part 108| | 109| | // An exponent marker must be followed by at least one digit, after an optional sign. Unlike 110| | // std::from_chars, which ends the number before a digitless marker, "1e", "1e+" and "1.0E-" are 111| | // rejected: ending early would read "1.0e" as 1 wherever trailing content goes unchecked. 112| | if constexpr (null_terminated) { 113| | if ((UC('e') == *p) || (UC('E') == *p)) { 114| | ++p; 115| | bool neg_exp = false; 116| | if (UC('-') == *p) { 117| | neg_exp = true; 118| | ++p; 119| | } 120| | else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) 121| | ++p; 122| | } 123| | if ((digit = glz::fast_float::digit_value(*p)) > 9) [[unlikely]] { 124| | return answer; 125| | } 126| | else { 127| | do { 128| | if (exp_number < 0x10000000) { 129| | exp_number = 10 * exp_number + digit; 130| | } 131| | ++p; 132| | } while ((digit = glz::fast_float::digit_value(*p)) <= 9); 133| | if (neg_exp) { 134| | exp_number = -exp_number; 135| | } 136| | exponent += exp_number; 137| | } 138| | } 139| | } 140| 1.28M| else { 141| 1.28M| if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) { ------------------ | Branch (141:14): [True: 1.28M, False: 1.69k] | Branch (141:30): [True: 53.8k, False: 1.22M] | Branch (141:49): [True: 7.97k, False: 1.22M] ------------------ 142| 61.7k| ++p; 143| 61.7k| bool neg_exp = false; 144| 61.7k| if ((p != pend) && (UC('-') == *p)) { ------------------ | Branch (144:17): [True: 61.7k, False: 7] | Branch (144:32): [True: 1.99k, False: 59.7k] ------------------ 145| 1.99k| neg_exp = true; 146| 1.99k| ++p; 147| 1.99k| } 148| 59.8k| else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) ------------------ | Branch (148:22): [True: 59.7k, False: 7] | Branch (148:37): [True: 200, False: 59.5k] ------------------ 149| 200| ++p; 150| 200| } 151| 61.7k| if ((p == pend) || (digit = glz::fast_float::digit_value(*p)) > 9) [[unlikely]] { ------------------ | Branch (151:17): [True: 13, False: 61.7k] | Branch (151:32): [True: 58, False: 61.7k] ------------------ 152| 71| return answer; 153| 71| } 154| 61.7k| else { 155| 114k| do { 156| 114k| if (exp_number < 0x10000000) { ------------------ | Branch (156:23): [True: 113k, False: 1.11k] ------------------ 157| 113k| exp_number = 10 * exp_number + digit; 158| 113k| } 159| 114k| ++p; 160| 114k| } while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9); ------------------ | Branch (160:25): [True: 114k, False: 598] | Branch (160:40): [True: 52.9k, False: 61.1k] ------------------ 161| 61.7k| if (neg_exp) { ------------------ | Branch (161:20): [True: 1.98k, False: 59.7k] ------------------ 162| 1.98k| exp_number = -exp_number; 163| 1.98k| } 164| 61.7k| exponent += exp_number; 165| 61.7k| } 166| 61.7k| } 167| 1.28M| } 168| | 169| 1.28M| answer.lastmatch = p; 170| 1.28M| answer.valid = true; 171| | 172| | // If we frequently had to deal with long strings of digits, 173| | // we could extend our code by using a 128-bit integer instead 174| | // of a 64-bit integer. However, this is uncommon. 175| | // 176| | // We can deal with up to 19 digits. 177| 1.28M| if (digit_count > 19) { // this is uncommon ------------------ | Branch (177:11): [True: 22.8k, False: 1.26M] ------------------ 178| | // It is possible that the integer had an overflow. 179| | // We have to handle the case where we have 0.0000somenumber. 180| | // We need to be mindful of the case where we only have zeroes... 181| | // E.g., 0.000000000...000. 182| 22.8k| UC const* start = start_digits; 183| | if constexpr (null_terminated) { 184| | while ((*start == UC('0') || *start == decimal_point)) { 185| | if (*start == UC('0')) { 186| | --digit_count; 187| | } 188| | ++start; 189| | } 190| | } 191| 22.8k| else { 192| 4.42M| while ((start != pend) && (*start == UC('0') || *start == decimal_point)) { ------------------ | Branch (192:20): [True: 4.42M, False: 28] | Branch (192:40): [True: 4.40M, False: 28.1k] | Branch (192:61): [True: 5.39k, False: 22.7k] ------------------ 193| 4.40M| if (*start == UC('0')) { ------------------ | Branch (193:20): [True: 4.40M, False: 5.39k] ------------------ 194| 4.40M| --digit_count; 195| 4.40M| } 196| 4.40M| ++start; 197| 4.40M| } 198| 22.8k| } 199| | 200| 22.8k| if (digit_count > 19) { ------------------ | Branch (200:14): [True: 21.1k, False: 1.67k] ------------------ 201| 21.1k| answer.too_many_digits = true; 202| | // Let us start again, this time, avoiding overflows. 203| | // We don't need to check if is_integer, since we use the 204| | // pre-tokenized spans from above. 205| 21.1k| i = 0; 206| 21.1k| p = answer.integer.ptr; 207| 21.1k| UC const* int_end = p + answer.integer.len(); 208| 21.1k| const uint64_t minimal_nineteen_digit_integer{1000000000000000000}; 209| 301k| while ((i < minimal_nineteen_digit_integer) && (p != int_end)) { ------------------ | Branch (209:20): [True: 289k, False: 12.0k] | Branch (209:60): [True: 280k, False: 9.11k] ------------------ 210| 280k| i = i * 10 + uint64_t(*p - UC('0')); 211| 280k| ++p; 212| 280k| } 213| 21.1k| if (i >= minimal_nineteen_digit_integer) { // We have a big integers ------------------ | Branch (213:17): [True: 12.0k, False: 9.11k] ------------------ 214| 12.0k| exponent = end_of_integer_part - p + exp_number; 215| 12.0k| } 216| 9.11k| else { // We have a value with a fractional component. 217| 9.11k| p = answer.fraction.ptr; 218| 9.11k| UC const* frac_end = p + answer.fraction.len(); 219| 395k| while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) { ------------------ | Branch (219:23): [True: 386k, False: 9.11k] | Branch (219:63): [True: 386k, False: 0] ------------------ 220| 386k| i = i * 10 + uint64_t(*p - UC('0')); 221| 386k| ++p; 222| 386k| } 223| 9.11k| exponent = answer.fraction.ptr - p + exp_number; 224| 9.11k| } 225| | // We have now corrected both exponent and i, to a truncated value 226| 21.1k| } 227| 22.8k| } 228| 1.28M| answer.exponent = exponent; 229| 1.28M| answer.mantissa = i; 230| 1.28M| return answer; 231| 1.28M| } _ZZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_ENKUlvE_clEv: 71| 1.28M| const bool has_decimal_point = [&] { 72| | if constexpr (null_terminated) { 73| | return (*p == decimal_point); 74| | } 75| 1.28M| else { 76| 1.28M| return (p != pend) && (*p == decimal_point); ------------------ | Branch (76:20): [True: 1.28M, False: 633] | Branch (76:35): [True: 21.7k, False: 1.26M] ------------------ 77| 1.28M| } 78| 1.28M| }(); _ZN3glz8to_charsImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_: 221| 4.56M| { 222| 4.56M| using namespace itoa_impl; 223| 4.56M| if (val < 100000000) { ------------------ | Branch (223:11): [True: 4.56M, False: 0] ------------------ 224| 4.56M| return u64_len_1_8(buf, uint32_t(val)); 225| 4.56M| } 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.56M| } _ZN3glz9itoa_impl11u64_len_1_8EPcj: 157| 4.56M| { 158| 4.56M| if (val < 100) { ------------------ | Branch (158:14): [True: 4.55M, False: 9.02k] ------------------ 159| 4.55M| return u32_2(buf, val); 160| 4.55M| } 161| 9.02k| else if (val < 10000) { ------------------ | Branch (161:19): [True: 7.94k, False: 1.08k] ------------------ 162| 7.94k| return u32_4(buf, val); 163| 7.94k| } 164| 1.08k| else if (val < 1000000) { ------------------ | Branch (164:19): [True: 989, False: 91] ------------------ 165| 989| return u32_6(buf, val); 166| 989| } 167| 91| else { 168| 91| return u32_8(buf, val); 169| 91| } 170| 4.56M| } _ZN3glz9itoa_impl5u32_2EPcj: 74| 4.55M| { 75| 4.55M| const uint32_t lz = val < 10; 76| 4.55M| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 77| 4.55M| return buf + 2 - lz; 78| 4.55M| } _ZN3glz9itoa_impl5u32_4EPcj: 81| 7.94k| { 82| 7.94k| const uint32_t aa = (val * 5243) >> 19; // val / 100 83| 7.94k| const uint32_t lz = aa < 10; 84| 7.94k| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 85| 7.94k| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 86| 7.94k| return buf + 4 - lz; 87| 7.94k| } _ZN3glz9itoa_impl5u32_6EPcj: 90| 989| { 91| 989| const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); // val / 10000 92| 989| const uint32_t bbcc = val - aa * 10000; 93| 989| const uint32_t bb = (bbcc * 5243) >> 19; // bbcc / 100 94| 989| const uint32_t lz = aa < 10; 95| 989| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 96| 989| std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2); 97| 989| std::memcpy(buf + 4 - lz, &digit_pairs[bbcc - bb * 100], 2); 98| 989| return buf + 6 - lz; 99| 989| } _ZN3glz9itoa_impl5u32_8EPcj: 102| 91| { 103| 91| const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40); // val / 10000 104| 91| const uint32_t ccdd = val - aabb * 10000; 105| 91| const uint32_t aa = (aabb * 5243) >> 19; // aabb / 100 106| 91| const uint32_t cc = (ccdd * 5243) >> 19; // ccdd / 100 107| 91| const uint32_t lz = aa < 10; 108| 91| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 109| 91| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 110| 91| std::memcpy(buf + 4 - lz, &digit_pairs[cc], 2); 111| 91| std::memcpy(buf + 6 - lz, &digit_pairs[ccdd - cc * 100], 2); 112| 91| return buf + 8 - lz; 113| 91| } _ZN3glz13to_chars_40kbIlQsr3stdE7same_asIu14__remove_cvrefIT_ElEEEPcS3_S1_: 328| 33.2k| { 329| 33.2k| *buf = '-'; 330| 33.2k| return to_chars_40kb(buf + (val < 0), 331| 33.2k| static_cast((static_cast(val) ^ (val >> 63)) - (val >> 63))); 332| 33.2k| } _ZN3glz13to_chars_40kbImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_: 291| 33.2k| { 292| 33.2k| using namespace itoa_40kb_impl; 293| 33.2k| if (val < 10000) { ------------------ | Branch (293:11): [True: 27.2k, False: 6.03k] ------------------ 294| 27.2k| if (val < 100) ------------------ | Branch (294:14): [True: 26.6k, False: 587] ------------------ 295| 26.6k| return u64_2(buf, val); 296| 587| else 297| 587| return u64_4(buf, val); 298| 27.2k| } 299| 6.03k| else if (val < 100000000) { ------------------ | Branch (299:16): [True: 789, False: 5.24k] ------------------ 300| 789| if (val < 1000000) ------------------ | Branch (300:14): [True: 340, False: 449] ------------------ 301| 340| return u64_6(buf, val); 302| 449| else 303| 449| return u64_8(buf, val); 304| 789| } 305| 5.24k| else if (val < 1000000000000ULL) { ------------------ | Branch (305:16): [True: 773, False: 4.47k] ------------------ 306| 773| if (val < 10000000000ULL) ------------------ | Branch (306:14): [True: 342, False: 431] ------------------ 307| 342| return u64_10(buf, val); 308| 431| else 309| 431| return u64_12(buf, val); 310| 773| } 311| 4.47k| else if (val < 10000000000000000ULL) { ------------------ | Branch (311:16): [True: 741, False: 3.72k] ------------------ 312| 741| if (val < 100000000000000ULL) ------------------ | Branch (312:14): [True: 359, False: 382] ------------------ 313| 359| return u64_14(buf, val); 314| 382| else 315| 382| return u64_16(buf, val); 316| 741| } 317| 3.72k| else if (val < 1000000000000000000ULL) { ------------------ | Branch (317:16): [True: 3.40k, False: 325] ------------------ 318| 3.40k| return u64_18(buf, val); 319| 3.40k| } 320| 325| else { 321| 325| return u64_20(buf, val); 322| 325| } 323| 33.2k| } _ZN3glz14itoa_40kb_impl5u64_2EPcm: 114| 26.6k| { 115| 26.6k| const uint64_t lz = val < 10; 116| 26.6k| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 117| 26.6k| return buf + 2 - lz; 118| 26.6k| } _ZN3glz14itoa_40kb_impl5u64_4EPcm: 121| 587| { 122| 587| const uint64_t aa = (val * 5243ULL) >> 19; 123| 587| const uint64_t lz = val < 1000; 124| 587| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 125| 587| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 126| 587| return buf + 4 - lz; 127| 587| } _ZN3glz14itoa_40kb_impl5u64_6EPcm: 130| 340| { 131| 340| const uint64_t aa = (val * 429497ULL) >> 32; 132| 340| const uint64_t lz = val < 100000; 133| 340| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 134| 340| std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4); 135| 340| return buf + 6 - lz; 136| 340| } _ZN3glz14itoa_40kb_impl5u64_8EPcm: 139| 449| { 140| 449| const uint64_t aabb = (val * 109951163ULL) >> 40; 141| 449| const uint64_t aa = (aabb * 5243ULL) >> 19; 142| 449| const uint64_t lz = val < 10000000; 143| 449| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 144| 449| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 145| 449| std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4); 146| 449| return buf + 8 - lz; 147| 449| } _ZN3glz14itoa_40kb_impl6u64_10EPcm: 150| 342| { 151| 342| const uint64_t high = div_1e8(val); 152| 342| const uint64_t low = val - high * 100000000; 153| 342| const uint64_t lz = high < 10; 154| 342| std::memcpy(buf, char_table + ((high * 2) | lz), 2); 155| 342| const uint64_t aabb = (low * 109951163ULL) >> 40; 156| 342| const uint64_t ccdd = low - aabb * 10000; 157| 342| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 158| 342| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 159| 342| return buf + 10 - lz; 160| 342| } _ZN3glz14itoa_40kb_impl7div_1e8Em: 50| 9.08k| { 51| 9.08k| constexpr __uint128_t multiplier = 0xabcc77118461cefdULL; 52| 9.08k| constexpr uint64_t shift = 90; 53| 9.08k| return static_cast((static_cast<__uint128_t>(value) * multiplier) >> shift); 54| 9.08k| } _ZN3glz14itoa_40kb_impl6u64_12EPcm: 163| 431| { 164| 431| const uint64_t high = div_1e8(val); 165| 431| const uint64_t low = val - high * 100000000; 166| 431| const uint64_t aa = (high * 5243ULL) >> 19; 167| 431| const uint64_t lz = aa < 10; 168| 431| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 169| 431| std::memcpy(buf + 2 - lz, &digit_pairs[high - aa * 100], 2); 170| 431| const uint64_t aabb = (low * 109951163ULL) >> 40; 171| 431| const uint64_t ccdd = low - aabb * 10000; 172| 431| std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4); 173| 431| std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4); 174| 431| return buf + 12 - lz; 175| 431| } _ZN3glz14itoa_40kb_impl6u64_14EPcm: 178| 359| { 179| 359| const uint64_t high = div_1e8(val); 180| 359| const uint64_t low = val - high * 100000000; 181| 359| const uint64_t aa = (high * 429497ULL) >> 32; 182| 359| const uint64_t lz = aa < 10; 183| 359| const uint64_t bbcc = high - aa * 10000; 184| 359| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 185| 359| std::memcpy(buf + 2 - lz, &digit_quads[bbcc], 4); 186| 359| const uint64_t aabb = (low * 109951163ULL) >> 40; 187| 359| const uint64_t ccdd = low - aabb * 10000; 188| 359| std::memcpy(buf + 6 - lz, &digit_quads[aabb], 4); 189| 359| std::memcpy(buf + 10 - lz, &digit_quads[ccdd], 4); 190| 359| return buf + 14 - lz; 191| 359| } _ZN3glz14itoa_40kb_impl6u64_16EPcm: 194| 382| { 195| 382| const uint64_t high = div_1e8(val); 196| 382| const uint64_t low = val - high * 100000000; 197| 382| uint64_t aabb = (high * 109951163ULL) >> 40; 198| 382| uint64_t ccdd = high - aabb * 10000; 199| 382| const uint64_t aa = (aabb * 5243ULL) >> 19; 200| 382| const uint64_t lz = aa < 10; 201| 382| const uint64_t bb = aabb - aa * 100; 202| 382| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 203| 382| std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2); 204| 382| std::memcpy(buf + 4 - lz, &digit_quads[ccdd], 4); 205| 382| aabb = (low * 109951163ULL) >> 40; 206| 382| ccdd = low - aabb * 10000; 207| 382| std::memcpy(buf + 8 - lz, &digit_quads[aabb], 4); 208| 382| std::memcpy(buf + 12 - lz, &digit_quads[ccdd], 4); 209| 382| return buf + 16 - lz; 210| 382| } _ZN3glz14itoa_40kb_impl6u64_18EPcm: 213| 3.40k| { 214| 3.40k| const uint64_t high = div_1e8(val); 215| 3.40k| const uint64_t low = val - high * 100000000; 216| 3.40k| const uint64_t high10 = div_1e8(high); 217| 3.40k| const uint64_t low10 = high - high10 * 100000000; 218| 3.40k| const uint64_t lz = high10 < 10; 219| 3.40k| std::memcpy(buf, char_table + ((high10 * 2) | lz), 2); 220| 3.40k| uint64_t aabb = (low10 * 109951163ULL) >> 40; 221| 3.40k| uint64_t ccdd = low10 - aabb * 10000; 222| 3.40k| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 223| 3.40k| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 224| 3.40k| aabb = (low * 109951163ULL) >> 40; 225| 3.40k| ccdd = low - aabb * 10000; 226| 3.40k| std::memcpy(buf + 10 - lz, &digit_quads[aabb], 4); 227| 3.40k| std::memcpy(buf + 14 - lz, &digit_quads[ccdd], 4); 228| 3.40k| return buf + 18 - lz; 229| 3.40k| } _ZN3glz14itoa_40kb_impl6u64_20EPcm: 232| 325| { 233| 325| const uint64_t high = div_1e8(val); 234| 325| const uint64_t low = val - high * 100000000; 235| 325| const uint64_t high12 = div_1e8(high); 236| 325| const uint64_t low12 = high - high12 * 100000000; 237| 325| const uint64_t aa = (high12 * 5243ULL) >> 19; 238| 325| const uint64_t lz = aa < 10; 239| 325| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 240| 325| std::memcpy(buf + 2 - lz, &digit_pairs[high12 - aa * 100], 2); 241| 325| uint64_t aabb = (low12 * 109951163ULL) >> 40; 242| 325| uint64_t ccdd = low12 - aabb * 10000; 243| 325| std::memcpy(buf + 4 - lz, &digit_quads[aabb], 4); 244| 325| std::memcpy(buf + 8 - lz, &digit_quads[ccdd], 4); 245| 325| aabb = (low * 109951163ULL) >> 40; 246| 325| ccdd = low - aabb * 10000; 247| 325| std::memcpy(buf + 12 - lz, &digit_quads[aabb], 4); 248| 325| std::memcpy(buf + 16 - lz, &digit_quads[ccdd], 4); 249| 325| return buf + 20 - lz; 250| 325| } _ZN3glz13to_chars_40kbIiQsr3stdE7same_asIu14__remove_cvrefIT_EiEEEPcS3_S1_: 282| 894| { 283| 894| *buf = '-'; 284| 894| return to_chars_40kb(buf + (val < 0), 285| 894| static_cast((static_cast(val) ^ (val >> 31)) - (val >> 31))); 286| 894| } _ZN3glz13to_chars_40kbIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_: 260| 894| { 261| 894| using namespace itoa_40kb_impl; 262| 894| if (val < 10000) { ------------------ | Branch (262:11): [True: 523, False: 371] ------------------ 263| 523| if (val < 100) ------------------ | Branch (263:14): [True: 438, False: 85] ------------------ 264| 438| return u32_2(buf, val); 265| 85| else 266| 85| return u32_4(buf, val); 267| 523| } 268| 371| else if (val < 100000000) { ------------------ | Branch (268:16): [True: 262, False: 109] ------------------ 269| 262| if (val < 1000000) ------------------ | Branch (269:14): [True: 111, False: 151] ------------------ 270| 111| return u32_6(buf, val); 271| 151| else 272| 151| return u32_8(buf, val); 273| 262| } 274| 109| else { 275| 109| return u32_10(buf, val); 276| 109| } 277| 894| } _ZN3glz14itoa_40kb_impl5u32_2EPcj: 62| 438| { 63| 438| const uint64_t lz = val < 10; 64| | // Use OR since val*2 is always even (bit 0 is 0) 65| 438| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 66| 438| return buf + 2 - lz; 67| 438| } _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| 111| { 80| 111| const uint32_t aa = static_cast((static_cast(val) * 429497ULL) >> 32); 81| 111| const uint64_t lz = val < 100000; 82| 111| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 83| 111| std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4); 84| 111| return buf + 6 - lz; 85| 111| } _ZN3glz14itoa_40kb_impl5u32_8EPcj: 88| 151| { 89| 151| const uint64_t aabb = (static_cast(val) * 109951163ULL) >> 40; 90| 151| const uint64_t aa = (aabb * 5243ULL) >> 19; 91| 151| const uint64_t lz = val < 10000000; 92| 151| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 93| 151| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 94| 151| std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4); 95| 151| return buf + 8 - lz; 96| 151| } _ZN3glz14itoa_40kb_impl6u32_10EPcj: 99| 109| { 100| 109| const uint64_t high = div_1e8(val); 101| 109| const uint64_t low = val - high * 100000000; 102| 109| const uint64_t lz = high < 10; 103| 109| std::memcpy(buf, char_table + ((high * 2) | lz), 2); 104| 109| const uint64_t aabb = (low * 109951163ULL) >> 40; 105| 109| const uint64_t ccdd = low - aabb * 10000; 106| 109| std::memcpy(buf + 2 - lz, &digit_quads[aabb], 4); 107| 109| std::memcpy(buf + 6 - lz, &digit_quads[ccdd], 4); 108| 109| return buf + 10 - lz; 109| 109| } _ZN3glz7skip_wsIXtlNS_7ws_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEbOT0_OT1_T2_: 663| 34.4M| { 664| 34.4M| using namespace glz::detail; 665| | 666| 34.4M| if constexpr (not Opts.minified) { 667| | if constexpr (Opts.null_terminated) { 668| | if constexpr (Opts.comments) { 669| | while (whitespace_comment_table[uint8_t(*it)]) { 670| | if (*it == '/') [[unlikely]] { 671| | skip_comment(ctx, it, end); 672| | if (bool(ctx.error)) [[unlikely]] { 673| | return true; 674| | } 675| | } 676| | else [[likely]] { 677| | ++it; 678| | } 679| | } 680| | } 681| | else { 682| | while (whitespace_table[uint8_t(*it)]) { 683| | ++it; 684| | } 685| | } 686| | } 687| 34.4M| else { 688| | if constexpr (Opts.comments) { 689| | while (it < end && whitespace_comment_table[uint8_t(*it)]) { 690| | if (*it == '/') [[unlikely]] { 691| | skip_comment(ctx, it, end); 692| | if (bool(ctx.error)) [[unlikely]] { 693| | return true; 694| | } 695| | } 696| | else [[likely]] { 697| | ++it; 698| | } 699| | } 700| | if (it == end) [[unlikely]] { 701| | ctx.error = error_code::end_reached; 702| | return true; 703| | } 704| | } 705| 34.4M| else { 706| 64.3M| while (it < end && whitespace_table[uint8_t(*it)]) { ------------------ | Branch (706:23): [True: 64.3M, False: 1.57k] | Branch (706:35): [True: 29.8M, False: 34.4M] ------------------ 707| 29.8M| ++it; 708| 29.8M| } 709| 34.4M| if (it == end) [[unlikely]] { ------------------ | Branch (709:20): [True: 1.57k, False: 34.4M] ------------------ 710| 1.57k| ctx.error = error_code::end_reached; 711| 1.57k| return true; 712| 1.57k| } 713| 34.4M| } 714| 34.4M| } 715| | } 716| | else if constexpr (not Opts.null_terminated) { 717| | // Minified input has no whitespace to skip, but a non-null-terminated buffer can still 718| | // be exhausted at this point. The non-minified branch above performs the same check; a 719| | // null-terminated buffer relies on the trailing sentinel and keeps this a pure no-op. 720| | if (it == end) [[unlikely]] { 721| | ctx.error = error_code::end_reached; 722| | return true; 723| | } 724| | } 725| | 726| 34.4M| return false; 727| 34.4M| } _ZN3glz17match_invalid_endILc123EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 470| 427k| { 471| 427k| if (*it != C) [[unlikely]] { ------------------ | Branch (471:11): [True: 229k, False: 198k] ------------------ 472| | if constexpr (C == '"') { 473| | ctx.error = error_code::expected_quote; 474| | } 475| | else if constexpr (C == ',') { 476| | ctx.error = error_code::expected_comma; 477| | } 478| | else if constexpr (C == ':') { 479| | ctx.error = error_code::expected_colon; 480| | } 481| | else if constexpr (C == '[' || C == ']') { 482| | ctx.error = error_code::expected_bracket; 483| | } 484| 229k| else if constexpr (C == '{' || C == '}') { 485| 229k| ctx.error = error_code::expected_brace; 486| | } 487| | else { 488| | ctx.error = error_code::syntax_error; 489| | } 490| 229k| return true; 491| 229k| } 492| 198k| else [[likely]] { 493| 198k| ++it; 494| 198k| } 495| 198k| if constexpr (not Opts.null_terminated) { 496| 198k| if (it == end) [[unlikely]] { ------------------ | Branch (496:14): [True: 1, False: 198k] ------------------ 497| 1| ctx.error = error_code::unexpected_end; 498| 1| return true; 499| 1| } 500| 198k| } 501| 198k| return false; 502| 427k| } _ZN3glz17match_invalid_endILc44EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 470| 2.44M| { 471| 2.44M| if (*it != C) [[unlikely]] { ------------------ | Branch (471:11): [True: 9.39k, False: 2.43M] ------------------ 472| | if constexpr (C == '"') { 473| | ctx.error = error_code::expected_quote; 474| | } 475| 9.39k| else if constexpr (C == ',') { 476| 9.39k| ctx.error = error_code::expected_comma; 477| | } 478| | else if constexpr (C == ':') { 479| | ctx.error = error_code::expected_colon; 480| | } 481| | else if constexpr (C == '[' || C == ']') { 482| | ctx.error = error_code::expected_bracket; 483| | } 484| | else if constexpr (C == '{' || C == '}') { 485| | ctx.error = error_code::expected_brace; 486| | } 487| | else { 488| | ctx.error = error_code::syntax_error; 489| | } 490| 9.39k| return true; 491| 9.39k| } 492| 2.43M| else [[likely]] { 493| 2.43M| ++it; 494| 2.43M| } 495| 2.43M| if constexpr (not Opts.null_terminated) { 496| 2.43M| if (it == end) [[unlikely]] { ------------------ | Branch (496:14): [True: 1, False: 2.43M] ------------------ 497| 1| ctx.error = error_code::unexpected_end; 498| 1| return true; 499| 1| } 500| 2.43M| } 501| 2.43M| return false; 502| 2.44M| } _ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m: 730| 903k| { 731| 903k| if (length > 7) { ------------------ | Branch (731:11): [True: 779k, False: 123k] ------------------ 732| 779k| uint64_t v[2]; 733| 790k| while (length > 8) { ------------------ | Branch (733:17): [True: 87.4k, False: 703k] ------------------ 734| 87.4k| std::memcpy(v, ws, 8); 735| 87.4k| std::memcpy(v + 1, it, 8); 736| 87.4k| if (v[0] != v[1]) { ------------------ | Branch (736:17): [True: 76.3k, False: 11.0k] ------------------ 737| 76.3k| return; 738| 76.3k| } 739| 11.0k| length -= 8; 740| 11.0k| ws += 8; 741| 11.0k| it += 8; 742| 11.0k| } 743| | 744| 703k| const auto shift = 8 - length; 745| 703k| ws -= shift; 746| 703k| it -= shift; 747| | 748| 703k| std::memcpy(v, ws, 8); 749| 703k| std::memcpy(v + 1, it, 8); 750| 703k| if (v[0] != v[1]) { ------------------ | Branch (750:14): [True: 698k, False: 4.82k] ------------------ 751| 698k| return; 752| 698k| } 753| 4.82k| it += 8; 754| 4.82k| return; 755| 703k| } 756| 123k| { 757| 123k| constexpr uint64_t n{sizeof(uint32_t)}; 758| 123k| if (length >= n) { ------------------ | Branch (758:14): [True: 30.7k, False: 93.1k] ------------------ 759| 30.7k| uint32_t v[2]; 760| 30.7k| std::memcpy(v, ws, n); 761| 30.7k| std::memcpy(v + 1, it, n); 762| 30.7k| if (v[0] != v[1]) { ------------------ | Branch (762:17): [True: 25.2k, False: 5.51k] ------------------ 763| 25.2k| return; 764| 25.2k| } 765| 5.51k| length -= n; 766| 5.51k| ws += n; 767| 5.51k| it += n; 768| 5.51k| } 769| 123k| } 770| 98.6k| { 771| 98.6k| constexpr uint64_t n{sizeof(uint16_t)}; 772| 98.6k| if (length >= n) { ------------------ | Branch (772:14): [True: 48.6k, False: 49.9k] ------------------ 773| 48.6k| uint16_t v[2]; 774| 48.6k| std::memcpy(v, ws, n); 775| 48.6k| std::memcpy(v + 1, it, n); 776| 48.6k| if (v[0] != v[1]) { ------------------ | Branch (776:17): [True: 43.6k, False: 5.02k] ------------------ 777| 43.6k| return; 778| 43.6k| } 779| | // length -= n; 780| | // ws += n; 781| 5.02k| it += n; 782| 5.02k| } 783| 98.6k| } 784| | // We have to call a whitespace check after this function 785| | // in case the whitespace is mismatching. 786| | // So, we forgo this check as to not duplicate. 787| | /*if (length && *ws == *it) { 788| | ++it; 789| | }*/ 790| 98.6k| } _ZN3glz17match_invalid_endILc58EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 470| 3.85M| { 471| 3.85M| if (*it != C) [[unlikely]] { ------------------ | Branch (471:11): [True: 10.0k, False: 3.84M] ------------------ 472| | if constexpr (C == '"') { 473| | ctx.error = error_code::expected_quote; 474| | } 475| | else if constexpr (C == ',') { 476| | ctx.error = error_code::expected_comma; 477| | } 478| 10.0k| else if constexpr (C == ':') { 479| 10.0k| ctx.error = error_code::expected_colon; 480| | } 481| | else if constexpr (C == '[' || C == ']') { 482| | ctx.error = error_code::expected_bracket; 483| | } 484| | else if constexpr (C == '{' || C == '}') { 485| | ctx.error = error_code::expected_brace; 486| | } 487| | else { 488| | ctx.error = error_code::syntax_error; 489| | } 490| 10.0k| return true; 491| 10.0k| } 492| 3.84M| else [[likely]] { 493| 3.84M| ++it; 494| 3.84M| } 495| 3.84M| if constexpr (not Opts.null_terminated) { 496| 3.84M| if (it == end) [[unlikely]] { ------------------ | Branch (496:14): [True: 12, False: 3.84M] ------------------ 497| 12| ctx.error = error_code::unexpected_end; 498| 12| return true; 499| 12| } 500| 3.84M| } 501| 3.84M| return false; 502| 3.85M| } _ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb1EEELc123ELc125ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_8commentsEEvOT3_OT4_T5_: 1325| 163k| { 1326| 163k| static constexpr bool opening_not_handled = false; 1327| 163k| static constexpr bool skip_validation = false; 1328| | // skip_validation routes skip_string through the end-bounded skip_string_view path, which 1329| | // stops on `end` rather than on a sentinel, so this flag has no effect from here. 1330| 163k| static constexpr bool null_terminated_unused = true; 1331| | 1332| 163k| size_t depth = Depth; 1333| | 1334| 163k|#if defined(GLZ_STRUCTURAL_SIMD) 1335| 163k| if (skip_windows(it, end, depth)) { ------------------ | Branch (1335:11): [True: 67.7k, False: 95.5k] ------------------ 1336| 67.7k| return; 1337| 67.7k| } 1338| 95.5k|#endif 1339| | 1340| | // Chunked while eight bytes remain, then a byte at a time; a padded input has room for the 1341| | // load that straddles the end of the document and leaves the tail below unreachable. The 1342| | // bound is a pointer so each chunk costs one compare rather than a subtract and a compare, 1343| | // and is only formed once that much buffer is left for it to point into. Where it is not, the 1344| | // fallback is the opening bracket, which sits before `it` and so fails the test on the first 1345| | // look. Never `it` itself -- that passes, and the chunk behind it would read past `end`. 1346| 95.5k| const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 1347| 95.5k| const auto* const chunk_limit = (end - it >= scan_min) ? end - scan_min : it - 1; ------------------ | Branch (1347:39): [True: 94.9k, False: 585] ------------------ 1348| | 1349| 21.1M| while (it <= chunk_limit) { ------------------ | Branch (1349:14): [True: 21.0M, False: 22.6k] ------------------ 1350| 21.0M| uint64_t chunk; 1351| 21.0M| std::memcpy(&chunk, it, 8); 1352| | if constexpr (std::endian::native == std::endian::big) { 1353| | chunk = std::byteswap(chunk); 1354| | } 1355| 21.0M| const uint64_t test = has_quote(chunk) | has_char(chunk) | has_char(chunk); 1356| 21.0M| if (test) { ------------------ | Branch (1356:14): [True: 472k, False: 20.6M] ------------------ 1357| 472k| it += (countr_zero(test) >> 3); 1358| | 1359| 472k| switch (*it) { 1360| 299k| case '"': { ------------------ | Branch (1360:13): [True: 299k, False: 173k] ------------------ 1361| 299k| skip_string(ctx, it, end); 1363| 299k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1363:20): [True: 2.48k, False: 297k] ------------------ 1364| 2.48k| return; 1365| 2.48k| } 1366| 297k| break; 1367| 299k| } 1368| 297k| case open: { ------------------ | Branch (1368:13): [True: 64.2k, False: 408k] ------------------ 1369| 64.2k| ++it; 1370| 64.2k| ++depth; 1371| 64.2k| break; 1372| 299k| } 1373| 108k| case close: { ------------------ | Branch (1373:13): [True: 108k, False: 364k] ------------------ 1374| 108k| ++it; 1375| 108k| --depth; 1376| 108k| if (depth == 0) { ------------------ | Branch (1376:20): [True: 70.4k, False: 38.3k] ------------------ 1377| 70.4k| return; 1378| 70.4k| } 1379| 38.3k| break; 1380| 108k| } 1381| 38.3k| default: { ------------------ | Branch (1381:13): [True: 0, False: 472k] ------------------ 1382| 0| ctx.error = error_code::unexpected_end; 1383| 0| return; 1384| 108k| } 1385| 472k| } 1386| 472k| } 1387| 20.6M| else { 1388| 20.6M| it += 8; 1389| 20.6M| } 1390| 21.0M| } 1391| | 1392| | // Tail end of buffer. Should be rare we even get here 1393| 37.6k| while (it < end) { ------------------ | Branch (1393:14): [True: 36.9k, False: 748] ------------------ 1394| 36.9k| switch (*it) { 1395| 6.44k| case '"': { ------------------ | Branch (1395:10): [True: 6.44k, False: 30.4k] ------------------ 1396| 6.44k| skip_string(ctx, it, end); 1398| 6.44k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1398:17): [True: 907, False: 5.53k] ------------------ 1399| 907| return; 1400| 907| } 1401| 5.53k| break; 1402| 6.44k| } 1403| 5.53k| case open: { ------------------ | Branch (1403:10): [True: 295, False: 36.6k] ------------------ 1404| 295| ++it; 1405| 295| ++depth; 1406| 295| break; 1407| 6.44k| } 1408| 21.9k| case close: { ------------------ | Branch (1408:10): [True: 21.9k, False: 14.9k] ------------------ 1409| 21.9k| ++it; 1410| 21.9k| --depth; 1411| 21.9k| if (depth == 0) { ------------------ | Branch (1411:17): [True: 20.9k, False: 977] ------------------ 1412| 20.9k| return; 1413| 20.9k| } 1414| 977| break; 1415| 21.9k| } 1416| 8.23k| default: { ------------------ | Branch (1416:10): [True: 8.23k, False: 28.6k] ------------------ 1417| 8.23k| ++it; 1418| 8.23k| } 1419| 36.9k| } 1420| 36.9k| } 1421| | 1422| 748| ctx.error = error_code::unexpected_end; 1423| 748| } _ZN3glz12skip_windowsIXtlNS_22skip_until_closed_optsELb0ELb1EEELc123ELc125ERPKcS3_EEbOT2_T3_Rm: 1243| 163k| { 1244| 163k| uint64_t escape_carry{}; 1245| 163k| uint64_t in_string_carry{}; // all ones while the next window opens inside a string 1246| 163k| auto string_open = it; // opening quote of the string still open, when there is one 1247| | 1248| 2.42M| while (end - it >= 64) { ------------------ | Branch (1248:14): [True: 2.33M, False: 89.9k] ------------------ 1249| 2.33M| const auto w = detail::structural::load_window(it, Open, Close); 1250| | 1251| 2.33M| if constexpr (Opts.validate_utf8) { 1252| 2.33M| if (w.non_ascii) [[unlikely]] { ------------------ | Branch (1252:17): [True: 46.5k, False: 2.28M] ------------------ 1253| 46.5k| if (in_string_carry) { ------------------ | Branch (1253:20): [True: 2.70k, False: 43.8k] ------------------ 1254| 2.70k| it = string_open; 1255| 2.70k| } 1256| 46.5k| return false; 1257| 46.5k| } 1258| 2.33M| } 1259| | 1260| 2.28M| const uint64_t escaped = escaped_mask(w.backslash, escape_carry); 1261| 2.33M| const uint64_t quote = w.quote & ~escaped; 1262| 2.33M| const uint64_t in_string = prefix_xor(quote) ^ in_string_carry; 1263| | 1264| | // A backslash outside a string cannot occur in JSON, and the parity above takes it at 1265| | // face value: it cancels the next quote, and every byte after that is on the wrong side 1266| | // of the string boundary for the rest of the document. The byte scan reaches a backslash 1267| | // only through a string, so it does not make that mistake, and a malformed document must 1268| | // not be read one way here and another way on a target without these masks. Hand it over 1269| | // instead. The test is exact where it has to be -- at the first stray backslash nothing 1270| | // has diverged yet, so `in_string` is still right about it -- and anything it flags later 1271| | // only costs a window. 1272| 2.33M| if (w.backslash & ~in_string) [[unlikely]] { ------------------ | Branch (1272:14): [True: 5.62k, False: 2.32M] ------------------ 1273| 5.62k| if (in_string_carry) { ------------------ | Branch (1273:17): [True: 524, False: 5.10k] ------------------ 1274| 524| it = string_open; 1275| 524| } 1276| 5.62k| return false; 1277| 5.62k| } 1278| | 1279| 2.32M| in_string_carry = uint64_t(int64_t(in_string) >> 63); // sign extend the last byte's state 1280| 2.32M| if (in_string_carry && quote) { ------------------ | Branch (1280:14): [True: 1.05M, False: 1.26M] | Branch (1280:33): [True: 50.7k, False: 1.00M] ------------------ 1281| | // Ending inside a string means the window's last unescaped quote opened it. 1282| 50.7k| string_open = it + (63 - std::countl_zero(quote)); 1283| 50.7k| } 1284| | 1285| 2.32M| const uint64_t opens = w.open & ~in_string; 1286| 2.32M| const uint64_t closes = w.close & ~in_string; 1287| | 1288| | // Every close in the window drops the depth by one at most, so a depth above that count 1289| | // cannot reach zero anywhere inside it and the net change is all that matters. 1290| 2.32M| if (depth > size_t(std::popcount(closes))) { ------------------ | Branch (1290:14): [True: 2.20M, False: 117k] ------------------ 1291| 2.20M| depth += size_t(std::popcount(opens)); 1292| 2.20M| depth -= size_t(std::popcount(closes)); 1293| 2.20M| it += 64; 1294| 2.20M| continue; 1295| 2.20M| } 1296| | 1297| 117k| uint64_t brackets = opens | closes; 1298| 149k| while (brackets) { ------------------ | Branch (1298:17): [True: 100k, False: 49.6k] ------------------ 1299| 100k| const auto i = countr_zero(brackets); 1300| 100k| brackets &= brackets - 1; 1301| 100k| if ((closes >> i) & 1) { ------------------ | Branch (1301:17): [True: 84.6k, False: 15.6k] ------------------ 1302| 84.6k| --depth; 1303| 84.6k| if (depth == 0) { ------------------ | Branch (1303:20): [True: 67.7k, False: 16.8k] ------------------ 1304| 67.7k| it += i + 1; 1305| 67.7k| return true; 1306| 67.7k| } 1307| 84.6k| } 1308| 15.6k| else { 1309| 15.6k| ++depth; 1310| 15.6k| } 1311| 100k| } 1312| 49.6k| it += 64; 1313| 49.6k| } 1314| | 1315| 89.9k| if (in_string_carry) { ------------------ | Branch (1315:11): [True: 3.26k, False: 86.6k] ------------------ 1316| 3.26k| it = string_open; 1317| 3.26k| } 1318| 89.9k| return false; 1319| 163k| } _ZN3glz12escaped_maskEmRm: 1215| 2.80M| { 1216| 2.80M| if (backslash == 0) { ------------------ | Branch (1216:11): [True: 2.73M, False: 69.9k] ------------------ 1217| 2.73M| const uint64_t escaped = carry; 1218| 2.73M| carry = 0; 1219| 2.73M| return escaped; 1220| 2.73M| } 1221| 69.9k| backslash &= ~carry; 1222| 69.9k| const uint64_t follows_escape = (backslash << 1) | carry; 1223| 69.9k| constexpr uint64_t even_bits = 0x5555555555555555ull; 1224| 69.9k| const uint64_t odd_starts = backslash & ~even_bits & ~follows_escape; 1225| 69.9k| const uint64_t even_sequences = odd_starts + backslash; 1226| 69.9k| carry = uint64_t(even_sequences < odd_starts); // unsigned wraparound is the run crossing over 1227| 69.9k| return (even_bits ^ (even_sequences << 1)) & follows_escape; 1228| 2.80M| } _ZN3glz10prefix_xorEm: 1200| 2.80M| { 1201| 2.80M| x ^= x << 1; 1202| 2.80M| x ^= x << 2; 1203| 2.80M| x ^= x << 4; 1204| 2.80M| x ^= x << 8; 1205| 2.80M| x ^= x << 16; 1206| 2.80M| x ^= x << 32; 1207| 2.80M| return x; 1208| 2.80M| } _ZN3glz9chunk_minILm8EEElb: 47| 5.38M| { 48| 5.38M| static_assert(Width <= padding_bytes); 49| 5.38M| return padded ? 1 : std::ptrdiff_t(Width); ------------------ | Branch (49:14): [True: 0, False: 5.38M] ------------------ 50| 5.38M| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1012| 393k| { 1013| 393k| if constexpr (not Opts.opening_handled) { 1014| 393k| ++it; 1015| 393k| } 1016| | 1017| 393k| const auto* const utf8_start = it; 1018| | 1019| | if constexpr (Opts.validate_skipped) { 1020| | // The bound as a pointer, so each chunk costs one compare. `end - scan_min` is only a 1021| | // pointer into the buffer once at least that much of it is left, and a string can start 1022| | // within a few bytes of the end; where it is not, the fallback is the opening quote, which 1023| | // sits before `it` and so fails the test on the first look. Never `it` itself -- that 1024| | // passes, and the chunk behind it would read past the end of the buffer. 1025| | const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 1026| | const auto* const chunk_limit = (end - it >= scan_min) ? end - scan_min : it - 1; 1027| | 1028| | while (it <= chunk_limit) { 1029| | uint64_t swar; 1030| | std::memcpy(&swar, it, 8); 1031| | if constexpr (std::endian::native == std::endian::big) { 1032| | swar = std::byteswap(swar); 1033| | } 1034| | 1035| | constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1036| | const uint64_t lo7 = swar & lo7_mask; 1037| | const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1038| | const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1039| | const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1040| | uint64_t next = ~((backslash & quote & less_32) | swar); 1041| | next &= repeat_byte8(0b10000000); 1042| | 1043| | if (next == 0) { 1044| | // No special characters in this chunk 1045| | it += 8; 1046| | continue; 1047| | } 1048| | 1049| | // Find the first occurrence 1050| | size_t offset = (countr_zero(next) >> 3); 1051| | it += offset; 1052| | 1053| | const auto c = *it; 1054| | if ((c & 0b11100000) == 0) [[unlikely]] { 1055| | // Invalid control character (<0x20) 1056| | ctx.error = error_code::syntax_error; 1057| | return; 1058| | } 1059| | else if (c == '"') { 1060| | // Check if this quote is escaped 1061| | const auto* p = it - 1; 1062| | int backslash_count{}; 1063| | // We don't have to worry about rewinding too far because we started with a quote 1064| | while (*p == '\\') { 1065| | ++backslash_count; 1066| | --p; 1067| | } 1068| | if ((backslash_count & 1) == 0) { 1069| | // Even number of backslashes => not escaped => closing quote found 1070| | validate_utf8_span(ctx, utf8_start, it); 1071| | ++it; 1072| | return; 1073| | } 1074| | else { 1075| | // Odd number of backslashes => escaped quote 1076| | ++it; 1077| | continue; 1078| | } 1079| | } 1080| | else if (c == '\\') { 1081| | // Handle escape sequence 1082| | ++it; 1083| | 1084| | // The backslash can be the last byte the chunk covers, which lands `it` on `end`. 1085| | // A null-terminated buffer answers that read with its terminator, which the escape 1086| | // table below rejects; a bounded one has nothing there to read. 1087| | if constexpr (not Opts.null_terminated) { 1088| | if (it == end) [[unlikely]] { 1089| | ctx.error = error_code::unexpected_end; 1090| | return; 1091| | } 1092| | } 1093| | 1094| | if (*it == 'u') { 1095| | ++it; 1096| | if (not skip_unicode_code_point(it, end)) [[unlikely]] { 1097| | ctx.error = error_code::unicode_escape_conversion_failure; 1098| | return; 1099| | } 1100| | } 1101| | else { 1102| | if (not char_unescape_table[uint8_t(*it)]) [[unlikely]] { 1103| | ctx.error = error_code::invalid_escape; 1104| | return; 1105| | } 1106| | ++it; 1107| | } 1108| | } 1109| | } 1110| | 1111| | while (true) { 1112| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1113| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1114| | // scan before each dereference. 1115| | if constexpr (not Opts.null_terminated) { 1116| | if (it == end) [[unlikely]] { 1117| | ctx.error = error_code::unexpected_end; 1118| | return; 1119| | } 1120| | } 1121| | if ((*it & 0b11100000) == 0) [[unlikely]] { 1122| | ctx.error = error_code::syntax_error; 1123| | return; 1124| | } 1125| | 1126| | switch (*it) { 1127| | case '"': { 1128| | validate_utf8_span(ctx, utf8_start, it); 1129| | ++it; 1130| | return; 1131| | } 1132| | case '\\': { 1133| | ++it; 1134| | if constexpr (not Opts.null_terminated) { 1135| | if (it == end) [[unlikely]] { 1136| | ctx.error = error_code::unexpected_end; 1137| | return; 1138| | } 1139| | } 1140| | if (char_unescape_table[uint8_t(*it)]) { 1141| | ++it; 1142| | continue; 1143| | } 1144| | else if (*it == 'u') { 1145| | ++it; 1146| | if (skip_unicode_code_point(it, end)) [[likely]] { 1147| | continue; 1148| | } 1149| | else [[unlikely]] { 1150| | ctx.error = error_code::unicode_escape_conversion_failure; 1151| | return; 1152| | } 1153| | } 1154| | // Same code the chunked loop above reports. Both loops run over one buffer now, so 1155| | // an escape that lands in the last few bytes must be diagnosed the same as one that 1156| | // does not. 1157| | ctx.error = error_code::invalid_escape; 1158| | return; 1159| | } 1160| | } 1161| | ++it; 1162| | } 1163| | } 1164| 393k| else { 1165| 393k| uint64_t ascii_acc{}; 1166| 393k| skip_string_view(ctx, it, end, ascii_acc); 1167| 393k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1167:14): [True: 2.61k, False: 391k] ------------------ 1168| 2.61k| return; 1169| 2.61k| } 1170| 391k| if (validate_utf8_span(ctx, utf8_start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1170:14): [True: 2.01k, False: 389k] ------------------ 1171| 2.01k| return; 1172| 2.01k| } 1173| 389k| ++it; // skip the quote 1174| 389k| } 1175| 393k| } _ZN3glz16skip_string_viewITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_Rm: 910| 622k| { 911| | // The bound as a pointer, so each chunk costs one compare rather than a subtract and a 912| | // compare. `end - 8` is only a pointer into the buffer once eight bytes are left; where they 913| | // are not, the fallback is the opening quote, which sits before `it` and so fails the test on 914| | // the first look. Never `it` itself -- that passes, and the chunk behind it would read past 915| | // `end`. Reading eight at a time never passes `end`, so this is safe on buffers that are 916| | // neither padded nor null terminated. 917| 622k| const auto* const chunk_limit = (end - it >= 8) ? end - 8 : it - 1; ------------------ | Branch (917:39): [True: 588k, False: 34.3k] ------------------ 918| 29.4M| while (it <= chunk_limit) { ------------------ | Branch (918:14): [True: 29.4M, False: 44.7k] ------------------ 919| 29.4M| uint64_t chunk; 920| 29.4M| std::memcpy(&chunk, it, 8); 921| | if constexpr (std::endian::native == std::endian::big) { 922| | chunk = std::byteswap(chunk); 923| | } 924| 29.4M| const uint64_t test = has_quote(chunk); 925| 29.4M| if (test) [[unlikely]] { ------------------ | Branch (925:14): [True: 638k, False: 28.7M] ------------------ 926| 638k| const size_t offset = size_t(countr_zero(test)) >> 3; 927| | // Only bytes up to and including the quote belong to the string. Masking the rest off 928| | // keeps a non-ASCII byte in whatever follows from forcing a needless validation pass. 929| 638k| ascii_acc |= chunk & (~uint64_t(0) >> (56 - 8 * offset)); 930| 638k| it += offset; 931| 638k| auto* prev = it - 1; 932| 856k| while (*prev == '\\') { ------------------ | Branch (932:20): [True: 217k, False: 638k] ------------------ 933| 217k| --prev; 934| 217k| } 935| 638k| if (size_t(it - prev) % 2) { ------------------ | Branch (935:17): [True: 577k, False: 60.9k] ------------------ 936| 577k| return; 937| 577k| } 938| 60.9k| ++it; // skip the escaped quote 939| 60.9k| } 940| 28.7M| else { 941| 28.7M| ascii_acc |= chunk; 942| 28.7M| it += 8; 943| 28.7M| } 944| 29.4M| } 945| | 946| | // Fewer than eight bytes left in the buffer, so finish one at a time. 947| 140k| while (it < end) { ------------------ | Branch (947:14): [True: 137k, False: 2.76k] ------------------ 948| 137k| ascii_acc |= uint64_t(uint8_t(*it)); 949| 137k| if (*it == '"') { ------------------ | Branch (949:14): [True: 46.1k, False: 91.7k] ------------------ 950| 46.1k| auto* prev = it - 1; 951| 59.7k| while (*prev == '\\') { ------------------ | Branch (951:20): [True: 13.5k, False: 46.1k] ------------------ 952| 13.5k| --prev; 953| 13.5k| } 954| 46.1k| if (size_t(it - prev) % 2) { ------------------ | Branch (954:17): [True: 41.9k, False: 4.20k] ------------------ 955| 41.9k| return; 956| 41.9k| } 957| 46.1k| } 958| 95.9k| ++it; 959| 95.9k| } 960| | 961| 2.76k| ctx.error = error_code::expected_quote; 962| 2.76k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 873| 391k| { 874| | if constexpr (not check_validate_utf8(Opts)) { 875| | // Everything the caller computed for us is dead, which lets its scan loop drop the 876| | // accumulator entirely. 877| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 878| | return false; 879| | } 880| 391k| else { 881| 391k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (881:14): [True: 371k, False: 19.5k] ------------------ 882| 371k| return false; // pure ASCII is trivially well formed UTF-8 883| 371k| } 884| 19.5k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (884:14): [True: 2.01k, False: 17.5k] ------------------ 885| 2.01k| ctx.error = error_code::invalid_utf8; 886| 2.01k| return true; 887| 2.01k| } 888| 17.5k| return false; 889| 19.5k| } 890| 391k| } _ZN3glz13validate_utf8IcEEbPKT_m: 842| 465k| { 843| 465k| const uint8_t* it = reinterpret_cast(str); 844| 465k| const uint8_t* const end = it + size; 845| |#if defined(GLZ_UTF8_SIMD) 846| | // 16 is a measured compromise, not a register-size coincidence. The scalar path skips ASCII 8 847| | // bytes at a time, so on ASCII it stays ahead of the vector path's fixed setup cost until the 848| | // input is long enough for the 64 byte ASCII step to engage; on non-ASCII the vector path 849| | // wins from roughly 8 bytes. Raising the threshold buys a few percent on short ASCII and 850| | // costs up to 2.3x on mid length non-ASCII strings, so it stays low. 851| | if (size >= 16) { 852| | return detail::utf8_simd::validate(it, end); 853| | } 854| |#endif 855| 465k| return validate_utf8_scalar(it, end); 856| 465k| } _ZN3glz20validate_utf8_scalarEPKhS1_: 793| 465k| { 794| 33.7M| while (it < end) { ------------------ | Branch (794:14): [True: 33.2M, False: 446k] ------------------ 795| | // Optimistic SWAR check for ASCII 796| 33.2M| if (it + 8 <= end) { ------------------ | Branch (796:14): [True: 31.8M, False: 1.39M] ------------------ 797| 31.8M| uint64_t chunk; 798| 31.8M| std::memcpy(&chunk, it, 8); 799| 31.8M| if ((chunk & glz::repeat_byte8(0x80)) == 0) { ------------------ | Branch (799:17): [True: 30.5M, False: 1.36M] ------------------ 800| 30.5M| it += 8; 801| 30.5M| continue; 802| 30.5M| } 803| 31.8M| } 804| | 805| | // Byte-by-byte validation (standard conformant) 806| 2.76M| uint8_t byte = *it; 807| | 808| 2.76M| if (byte < 0x80) { ------------------ | Branch (808:14): [True: 2.35M, False: 405k] ------------------ 809| 2.35M| it++; 810| 2.35M| } 811| 405k| else if ((byte & 0xE0) == 0xC0) { ------------------ | Branch (811:19): [True: 172k, False: 232k] ------------------ 812| | // 2-byte sequence 813| 172k| if (it + 2 > end || (it[1] & 0xC0) != 0x80) return false; ------------------ | Branch (813:17): [True: 72, False: 172k] | Branch (813:33): [True: 3.76k, False: 168k] ------------------ 814| 168k| if (byte < 0xC2) return false; // Overlong ------------------ | Branch (814:17): [True: 187, False: 168k] ------------------ 815| 168k| it += 2; 816| 168k| } 817| 232k| else if ((byte & 0xF0) == 0xE0) { ------------------ | Branch (817:19): [True: 110k, False: 122k] ------------------ 818| | // 3-byte sequence 819| 110k| if (it + 3 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80) return false; ------------------ | Branch (819:17): [True: 78, False: 109k] | Branch (819:33): [True: 1.36k, False: 108k] | Branch (819:59): [True: 434, False: 108k] ------------------ 820| 108k| if (byte == 0xE0 && it[1] < 0xA0) return false; // Overlong ------------------ | Branch (820:17): [True: 33.7k, False: 74.4k] | Branch (820:33): [True: 209, False: 33.5k] ------------------ 821| 107k| if (byte == 0xED && it[1] >= 0xA0) return false; // Surrogate ------------------ | Branch (821:17): [True: 35.9k, False: 71.9k] | Branch (821:33): [True: 157, False: 35.8k] ------------------ 822| 107k| it += 3; 823| 107k| } 824| 122k| else if ((byte & 0xF8) == 0xF0) { ------------------ | Branch (824:19): [True: 113k, False: 9.45k] ------------------ 825| | // 4-byte sequence 826| 113k| if (it + 4 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80 || (it[3] & 0xC0) != 0x80) ------------------ | Branch (826:17): [True: 93, False: 113k] | Branch (826:33): [True: 2.10k, False: 111k] | Branch (826:59): [True: 367, False: 110k] | Branch (826:85): [True: 357, False: 110k] ------------------ 827| 2.92k| return false; 828| 110k| if (byte == 0xF0 && it[1] < 0x90) return false; // Overlong ------------------ | Branch (828:17): [True: 41.7k, False: 68.8k] | Branch (828:33): [True: 200, False: 41.5k] ------------------ 829| 110k| if (byte == 0xF4 && it[1] >= 0x90) return false; // > U+10FFFF ------------------ | Branch (829:17): [True: 51.4k, False: 58.9k] | Branch (829:33): [True: 150, False: 51.3k] ------------------ 830| 110k| if (byte > 0xF4) return false; // > U+10FFFF ------------------ | Branch (830:17): [True: 164, False: 110k] ------------------ 831| 110k| it += 4; 832| 110k| } 833| 9.45k| else { 834| 9.45k| return false; 835| 9.45k| } 836| 2.76M| } 837| | 838| 446k| return true; 839| 465k| } _ZN3glz17skip_until_closedIXtlNS_22skip_until_closed_optsELb0ELb1EEELc91ELc93ELm1ETkNS_10is_contextERNS_7contextERPKcS5_QntdtT_8commentsEEvOT3_OT4_T5_: 1325| 27.1k| { 1326| 27.1k| static constexpr bool opening_not_handled = false; 1327| 27.1k| static constexpr bool skip_validation = false; 1328| | // skip_validation routes skip_string through the end-bounded skip_string_view path, which 1329| | // stops on `end` rather than on a sentinel, so this flag has no effect from here. 1330| 27.1k| static constexpr bool null_terminated_unused = true; 1331| | 1332| 27.1k| size_t depth = Depth; 1333| | 1334| 27.1k|#if defined(GLZ_STRUCTURAL_SIMD) 1335| 27.1k| if (skip_windows(it, end, depth)) { ------------------ | Branch (1335:11): [True: 7.86k, False: 19.2k] ------------------ 1336| 7.86k| return; 1337| 7.86k| } 1338| 19.2k|#endif 1339| | 1340| | // Chunked while eight bytes remain, then a byte at a time; a padded input has room for the 1341| | // load that straddles the end of the document and leaves the tail below unreachable. The 1342| | // bound is a pointer so each chunk costs one compare rather than a subtract and a compare, 1343| | // and is only formed once that much buffer is left for it to point into. Where it is not, the 1344| | // fallback is the opening bracket, which sits before `it` and so fails the test on the first 1345| | // look. Never `it` itself -- that passes, and the chunk behind it would read past `end`. 1346| 19.2k| const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 1347| 19.2k| const auto* const chunk_limit = (end - it >= scan_min) ? end - scan_min : it - 1; ------------------ | Branch (1347:39): [True: 16.7k, False: 2.49k] ------------------ 1348| | 1349| 9.39M| while (it <= chunk_limit) { ------------------ | Branch (1349:14): [True: 9.38M, False: 6.94k] ------------------ 1350| 9.38M| uint64_t chunk; 1351| 9.38M| std::memcpy(&chunk, it, 8); 1352| | if constexpr (std::endian::native == std::endian::big) { 1353| | chunk = std::byteswap(chunk); 1354| | } 1355| 9.38M| const uint64_t test = has_quote(chunk) | has_char(chunk) | has_char(chunk); 1356| 9.38M| if (test) { ------------------ | Branch (1356:14): [True: 962k, False: 8.42M] ------------------ 1357| 962k| it += (countr_zero(test) >> 3); 1358| | 1359| 962k| switch (*it) { 1360| 85.1k| case '"': { ------------------ | Branch (1360:13): [True: 85.1k, False: 877k] ------------------ 1361| 85.1k| skip_string(ctx, it, end); 1363| 85.1k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1363:20): [True: 679, False: 84.4k] ------------------ 1364| 679| return; 1365| 679| } 1366| 84.4k| break; 1367| 85.1k| } 1368| 852k| case open: { ------------------ | Branch (1368:13): [True: 852k, False: 110k] ------------------ 1369| 852k| ++it; 1370| 852k| ++depth; 1371| 852k| break; 1372| 85.1k| } 1373| 25.2k| case close: { ------------------ | Branch (1373:13): [True: 25.2k, False: 937k] ------------------ 1374| 25.2k| ++it; 1375| 25.2k| --depth; 1376| 25.2k| if (depth == 0) { ------------------ | Branch (1376:20): [True: 11.6k, False: 13.6k] ------------------ 1377| 11.6k| return; 1378| 11.6k| } 1379| 13.6k| break; 1380| 25.2k| } 1381| 13.6k| default: { ------------------ | Branch (1381:13): [True: 0, False: 962k] ------------------ 1382| 0| ctx.error = error_code::unexpected_end; 1383| 0| return; 1384| 25.2k| } 1385| 962k| } 1386| 962k| } 1387| 8.42M| else { 1388| 8.42M| it += 8; 1389| 8.42M| } 1390| 9.38M| } 1391| | 1392| | // Tail end of buffer. Should be rare we even get here 1393| 20.0k| while (it < end) { ------------------ | Branch (1393:14): [True: 17.4k, False: 2.57k] ------------------ 1394| 17.4k| switch (*it) { 1395| 2.51k| case '"': { ------------------ | Branch (1395:10): [True: 2.51k, False: 14.9k] ------------------ 1396| 2.51k| skip_string(ctx, it, end); 1398| 2.51k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1398:17): [True: 559, False: 1.95k] ------------------ 1399| 559| return; 1400| 559| } 1401| 1.95k| break; 1402| 2.51k| } 1403| 1.95k| case open: { ------------------ | Branch (1403:10): [True: 1.02k, False: 16.4k] ------------------ 1404| 1.02k| ++it; 1405| 1.02k| ++depth; 1406| 1.02k| break; 1407| 2.51k| } 1408| 5.35k| case close: { ------------------ | Branch (1408:10): [True: 5.35k, False: 12.1k] ------------------ 1409| 5.35k| ++it; 1410| 5.35k| --depth; 1411| 5.35k| if (depth == 0) { ------------------ | Branch (1411:17): [True: 3.81k, False: 1.54k] ------------------ 1412| 3.81k| return; 1413| 3.81k| } 1414| 1.54k| break; 1415| 5.35k| } 1416| 8.56k| default: { ------------------ | Branch (1416:10): [True: 8.56k, False: 8.89k] ------------------ 1417| 8.56k| ++it; 1418| 8.56k| } 1419| 17.4k| } 1420| 17.4k| } 1421| | 1422| 2.57k| ctx.error = error_code::unexpected_end; 1423| 2.57k| } _ZN3glz12skip_windowsIXtlNS_22skip_until_closed_optsELb0ELb1EEELc91ELc93ERPKcS3_EEbOT2_T3_Rm: 1243| 27.1k| { 1244| 27.1k| uint64_t escape_carry{}; 1245| 27.1k| uint64_t in_string_carry{}; // all ones while the next window opens inside a string 1246| 27.1k| auto string_open = it; // opening quote of the string still open, when there is one 1247| | 1248| 541k| while (end - it >= 64) { ------------------ | Branch (1248:14): [True: 523k, False: 18.0k] ------------------ 1249| 523k| const auto w = detail::structural::load_window(it, Open, Close); 1250| | 1251| 523k| if constexpr (Opts.validate_utf8) { 1252| 523k| if (w.non_ascii) [[unlikely]] { ------------------ | Branch (1252:17): [True: 5.04k, False: 518k] ------------------ 1253| 5.04k| if (in_string_carry) { ------------------ | Branch (1253:20): [True: 527, False: 4.51k] ------------------ 1254| 527| it = string_open; 1255| 527| } 1256| 5.04k| return false; 1257| 5.04k| } 1258| 523k| } 1259| | 1260| 518k| const uint64_t escaped = escaped_mask(w.backslash, escape_carry); 1261| 523k| const uint64_t quote = w.quote & ~escaped; 1262| 523k| const uint64_t in_string = prefix_xor(quote) ^ in_string_carry; 1263| | 1264| | // A backslash outside a string cannot occur in JSON, and the parity above takes it at 1265| | // face value: it cancels the next quote, and every byte after that is on the wrong side 1266| | // of the string boundary for the rest of the document. The byte scan reaches a backslash 1267| | // only through a string, so it does not make that mistake, and a malformed document must 1268| | // not be read one way here and another way on a target without these masks. Hand it over 1269| | // instead. The test is exact where it has to be -- at the first stray backslash nothing 1270| | // has diverged yet, so `in_string` is still right about it -- and anything it flags later 1271| | // only costs a window. 1272| 523k| if (w.backslash & ~in_string) [[unlikely]] { ------------------ | Branch (1272:14): [True: 1.22k, False: 522k] ------------------ 1273| 1.22k| if (in_string_carry) { ------------------ | Branch (1273:17): [True: 209, False: 1.01k] ------------------ 1274| 209| it = string_open; 1275| 209| } 1276| 1.22k| return false; 1277| 1.22k| } 1278| | 1279| 522k| in_string_carry = uint64_t(int64_t(in_string) >> 63); // sign extend the last byte's state 1280| 522k| if (in_string_carry && quote) { ------------------ | Branch (1280:14): [True: 21.7k, False: 500k] | Branch (1280:33): [True: 5.50k, False: 16.2k] ------------------ 1281| | // Ending inside a string means the window's last unescaped quote opened it. 1282| 5.50k| string_open = it + (63 - std::countl_zero(quote)); 1283| 5.50k| } 1284| | 1285| 522k| const uint64_t opens = w.open & ~in_string; 1286| 522k| const uint64_t closes = w.close & ~in_string; 1287| | 1288| | // Every close in the window drops the depth by one at most, so a depth above that count 1289| | // cannot reach zero anywhere inside it and the net change is all that matters. 1290| 522k| if (depth > size_t(std::popcount(closes))) { ------------------ | Branch (1290:14): [True: 508k, False: 13.9k] ------------------ 1291| 508k| depth += size_t(std::popcount(opens)); 1292| 508k| depth -= size_t(std::popcount(closes)); 1293| 508k| it += 64; 1294| 508k| continue; 1295| 508k| } 1296| | 1297| 13.9k| uint64_t brackets = opens | closes; 1298| 26.2k| while (brackets) { ------------------ | Branch (1298:17): [True: 20.1k, False: 6.10k] ------------------ 1299| 20.1k| const auto i = countr_zero(brackets); 1300| 20.1k| brackets &= brackets - 1; 1301| 20.1k| if ((closes >> i) & 1) { ------------------ | Branch (1301:17): [True: 13.3k, False: 6.85k] ------------------ 1302| 13.3k| --depth; 1303| 13.3k| if (depth == 0) { ------------------ | Branch (1303:20): [True: 7.86k, False: 5.44k] ------------------ 1304| 7.86k| it += i + 1; 1305| 7.86k| return true; 1306| 7.86k| } 1307| 13.3k| } 1308| 6.85k| else { 1309| 6.85k| ++depth; 1310| 6.85k| } 1311| 20.1k| } 1312| 6.10k| it += 64; 1313| 6.10k| } 1314| | 1315| 18.0k| if (in_string_carry) { ------------------ | Branch (1315:11): [True: 1.15k, False: 16.8k] ------------------ 1316| 1.15k| it = string_open; 1317| 1.15k| } 1318| 18.0k| return false; 1319| 27.1k| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1012| 30.5k| { 1013| 30.5k| if constexpr (not Opts.opening_handled) { 1014| 30.5k| ++it; 1015| 30.5k| } 1016| | 1017| 30.5k| const auto* const utf8_start = it; 1018| | 1019| | if constexpr (Opts.validate_skipped) { 1020| | // The bound as a pointer, so each chunk costs one compare. `end - scan_min` is only a 1021| | // pointer into the buffer once at least that much of it is left, and a string can start 1022| | // within a few bytes of the end; where it is not, the fallback is the opening quote, which 1023| | // sits before `it` and so fails the test on the first look. Never `it` itself -- that 1024| | // passes, and the chunk behind it would read past the end of the buffer. 1025| | const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 1026| | const auto* const chunk_limit = (end - it >= scan_min) ? end - scan_min : it - 1; 1027| | 1028| | while (it <= chunk_limit) { 1029| | uint64_t swar; 1030| | std::memcpy(&swar, it, 8); 1031| | if constexpr (std::endian::native == std::endian::big) { 1032| | swar = std::byteswap(swar); 1033| | } 1034| | 1035| | constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1036| | const uint64_t lo7 = swar & lo7_mask; 1037| | const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1038| | const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1039| | const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1040| | uint64_t next = ~((backslash & quote & less_32) | swar); 1041| | next &= repeat_byte8(0b10000000); 1042| | 1043| | if (next == 0) { 1044| | // No special characters in this chunk 1045| | it += 8; 1046| | continue; 1047| | } 1048| | 1049| | // Find the first occurrence 1050| | size_t offset = (countr_zero(next) >> 3); 1051| | it += offset; 1052| | 1053| | const auto c = *it; 1054| | if ((c & 0b11100000) == 0) [[unlikely]] { 1055| | // Invalid control character (<0x20) 1056| | ctx.error = error_code::syntax_error; 1057| | return; 1058| | } 1059| | else if (c == '"') { 1060| | // Check if this quote is escaped 1061| | const auto* p = it - 1; 1062| | int backslash_count{}; 1063| | // We don't have to worry about rewinding too far because we started with a quote 1064| | while (*p == '\\') { 1065| | ++backslash_count; 1066| | --p; 1067| | } 1068| | if ((backslash_count & 1) == 0) { 1069| | // Even number of backslashes => not escaped => closing quote found 1070| | validate_utf8_span(ctx, utf8_start, it); 1071| | ++it; 1072| | return; 1073| | } 1074| | else { 1075| | // Odd number of backslashes => escaped quote 1076| | ++it; 1077| | continue; 1078| | } 1079| | } 1080| | else if (c == '\\') { 1081| | // Handle escape sequence 1082| | ++it; 1083| | 1084| | // The backslash can be the last byte the chunk covers, which lands `it` on `end`. 1085| | // A null-terminated buffer answers that read with its terminator, which the escape 1086| | // table below rejects; a bounded one has nothing there to read. 1087| | if constexpr (not Opts.null_terminated) { 1088| | if (it == end) [[unlikely]] { 1089| | ctx.error = error_code::unexpected_end; 1090| | return; 1091| | } 1092| | } 1093| | 1094| | if (*it == 'u') { 1095| | ++it; 1096| | if (not skip_unicode_code_point(it, end)) [[unlikely]] { 1097| | ctx.error = error_code::unicode_escape_conversion_failure; 1098| | return; 1099| | } 1100| | } 1101| | else { 1102| | if (not char_unescape_table[uint8_t(*it)]) [[unlikely]] { 1103| | ctx.error = error_code::invalid_escape; 1104| | return; 1105| | } 1106| | ++it; 1107| | } 1108| | } 1109| | } 1110| | 1111| | while (true) { 1112| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1113| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1114| | // scan before each dereference. 1115| | if constexpr (not Opts.null_terminated) { 1116| | if (it == end) [[unlikely]] { 1117| | ctx.error = error_code::unexpected_end; 1118| | return; 1119| | } 1120| | } 1121| | if ((*it & 0b11100000) == 0) [[unlikely]] { 1122| | ctx.error = error_code::syntax_error; 1123| | return; 1124| | } 1125| | 1126| | switch (*it) { 1127| | case '"': { 1128| | validate_utf8_span(ctx, utf8_start, it); 1129| | ++it; 1130| | return; 1131| | } 1132| | case '\\': { 1133| | ++it; 1134| | if constexpr (not Opts.null_terminated) { 1135| | if (it == end) [[unlikely]] { 1136| | ctx.error = error_code::unexpected_end; 1137| | return; 1138| | } 1139| | } 1140| | if (char_unescape_table[uint8_t(*it)]) { 1141| | ++it; 1142| | continue; 1143| | } 1144| | else if (*it == 'u') { 1145| | ++it; 1146| | if (skip_unicode_code_point(it, end)) [[likely]] { 1147| | continue; 1148| | } 1149| | else [[unlikely]] { 1150| | ctx.error = error_code::unicode_escape_conversion_failure; 1151| | return; 1152| | } 1153| | } 1154| | // Same code the chunked loop above reports. Both loops run over one buffer now, so 1155| | // an escape that lands in the last few bytes must be diagnosed the same as one that 1156| | // does not. 1157| | ctx.error = error_code::invalid_escape; 1158| | return; 1159| | } 1160| | } 1161| | ++it; 1162| | } 1163| | } 1164| 30.5k| else { 1165| 30.5k| uint64_t ascii_acc{}; 1166| 30.5k| skip_string_view(ctx, it, end, ascii_acc); 1167| 30.5k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1167:14): [True: 125, False: 30.4k] ------------------ 1168| 125| return; 1169| 125| } 1170| 30.4k| if (validate_utf8_span(ctx, utf8_start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1170:14): [True: 342, False: 30.1k] ------------------ 1171| 342| return; 1172| 342| } 1173| 30.1k| ++it; // skip the quote 1174| 30.1k| } 1175| 30.5k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb0ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 873| 30.4k| { 874| | if constexpr (not check_validate_utf8(Opts)) { 875| | // Everything the caller computed for us is dead, which lets its scan loop drop the 876| | // accumulator entirely. 877| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 878| | return false; 879| | } 880| 30.4k| else { 881| 30.4k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (881:14): [True: 28.3k, False: 2.06k] ------------------ 882| 28.3k| return false; // pure ASCII is trivially well formed UTF-8 883| 28.3k| } 884| 2.06k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (884:14): [True: 342, False: 1.71k] ------------------ 885| 342| ctx.error = error_code::invalid_utf8; 886| 342| return true; 887| 342| } 888| 1.71k| return false; 889| 2.06k| } 890| 30.4k| } _ZN3glz17match_invalid_endILc34EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 470| 5.13M| { 471| 5.13M| if (*it != C) [[unlikely]] { ------------------ | Branch (471:11): [True: 1.83k, False: 5.13M] ------------------ 472| 1.83k| if constexpr (C == '"') { 473| 1.83k| ctx.error = error_code::expected_quote; 474| | } 475| | else if constexpr (C == ',') { 476| | ctx.error = error_code::expected_comma; 477| | } 478| | else if constexpr (C == ':') { 479| | ctx.error = error_code::expected_colon; 480| | } 481| | else if constexpr (C == '[' || C == ']') { 482| | ctx.error = error_code::expected_bracket; 483| | } 484| | else if constexpr (C == '{' || C == '}') { 485| | ctx.error = error_code::expected_brace; 486| | } 487| | else { 488| | ctx.error = error_code::syntax_error; 489| | } 490| 1.83k| return true; 491| 1.83k| } 492| 5.13M| else [[likely]] { 493| 5.13M| ++it; 494| 5.13M| } 495| 5.13M| if constexpr (not Opts.null_terminated) { 496| 5.13M| if (it == end) [[unlikely]] { ------------------ | Branch (496:14): [True: 3, False: 5.13M] ------------------ 497| 3| ctx.error = error_code::unexpected_end; 498| 3| return true; 499| 3| } 500| 5.13M| } 501| 5.13M| return false; 502| 5.13M| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 873| 1.66M| { 874| | if constexpr (not check_validate_utf8(Opts)) { 875| | // Everything the caller computed for us is dead, which lets its scan loop drop the 876| | // accumulator entirely. 877| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 878| | return false; 879| | } 880| 1.66M| else { 881| 1.66M| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (881:14): [True: 1.63M, False: 30.9k] ------------------ 882| 1.63M| return false; // pure ASCII is trivially well formed UTF-8 883| 1.63M| } 884| 30.9k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (884:14): [True: 15.9k, False: 14.9k] ------------------ 885| 15.9k| ctx.error = error_code::invalid_utf8; 886| 15.9k| return true; 887| 15.9k| } 888| 14.9k| return false; 889| 30.9k| } 890| 1.66M| } _ZN3glz25handle_unicode_code_pointIccEENS_14unicode_resultERPKT_RPT0_S4_: 347| 66.9k| { 348| 66.9k| using namespace unicode; 349| | 350| 66.9k| if (end - it <= 4) [[unlikely]] { ------------------ | Branch (350:11): [True: 85, False: 66.9k] ------------------ 351| 85| return {0, escape_prefix_intact(it, end)}; 352| 85| } 353| 66.9k| const uint32_t high = hex_to_u32(it); 354| 66.9k| if (high == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (354:11): [True: 125, False: 66.7k] ------------------ 355| 125| return {}; 356| 125| } 357| 66.7k| it += 4; // skip the code point characters 358| | 359| 66.7k| uint32_t code_point; 360| | 361| 66.7k| if ((high & generic_surrogate_mask) == generic_surrogate_value) { ------------------ | Branch (361:11): [True: 4.52k, False: 62.2k] ------------------ 362| | // surrogate pair code points 363| 4.52k| if ((high & surrogate_mask) != high_surrogate_value) { ------------------ | Branch (363:14): [True: 18, False: 4.50k] ------------------ 364| 18| return {}; 365| 18| } 366| | 367| 4.50k| if (end - it <= 6) [[unlikely]] { ------------------ | Branch (367:14): [True: 74, False: 4.43k] ------------------ 368| 74| return {0, escape_prefix_intact(it, end)}; 369| 74| } 370| | // The next two characters must be `\u` 371| 4.43k| uint16_t u; 372| 4.43k| std::memcpy(&u, it, 2); 373| 4.43k| if (u != to_uint16_t(R"(\u)")) [[unlikely]] { ------------------ | Branch (373:14): [True: 90, False: 4.34k] ------------------ 374| 90| return {}; 375| 90| } 376| 4.34k| it += 2; 377| | // verify that second unicode escape sequence is present 378| 4.34k| const uint32_t low = hex_to_u32(it); 379| 4.34k| if (low == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (379:14): [True: 20, False: 4.32k] ------------------ 380| 20| return {}; 381| 20| } 382| 4.32k| it += 4; 383| | 384| 4.32k| if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] { ------------------ | Branch (384:14): [True: 55, False: 4.26k] ------------------ 385| 55| return {}; 386| 55| } 387| | 388| 4.26k| code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits; 389| 4.26k| code_point |= (low & surrogate_codepoint_mask); 390| 4.26k| code_point += surrogate_codepoint_offset; 391| 4.26k| } 392| 62.2k| else { 393| 62.2k| code_point = high; 394| 62.2k| } 395| 66.5k| const uint32_t offset = code_point_to_utf8(code_point, dst); 396| 66.5k| dst += offset; 397| 66.5k| return {offset, false}; 398| 66.7k| } _ZN3glz20escape_prefix_intactILb0EccEEbPKT0_PKT1_: 329| 85| { 330| 85| auto n = size_t(end - it); 331| | if constexpr (ExpectOpener) { 332| | if (n > 0 && it[0] != '\\') return false; 333| | if (n > 1 && it[1] != 'u') return false; 334| | if (n < 2) return true; 335| | it += 2; 336| | n -= 2; 337| | } 338| 179| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (338:26): [True: 179, False: 0] ------------------ 339| 179| if (digit_hex_table[uint8_t(it[i])] == 255) return false; ------------------ | Branch (339:14): [True: 85, False: 94] ------------------ 340| 179| } 341| 0| return true; 342| 85| } _ZN3glz10hex_to_u32EPKc: 224| 300k| { 225| 300k| constexpr auto& t = digit_hex_table; 226| 300k| 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])]}; 227| 300k| auto chunk = std::bit_cast(arr); 228| | // On big-endian, bit_cast produces bytes in opposite order than expected 229| | // byteswap to get consistent little-endian representation 230| | if constexpr (std::endian::native == std::endian::big) { 231| | chunk = std::byteswap(chunk); 232| | } 233| | // check that all hex characters are valid 234| 300k| if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] { ------------------ | Branch (234:11): [True: 5.45k, False: 295k] ------------------ 235| 5.45k| return 0xFFFFFFFFu; 236| 5.45k| } 237| | 238| | // now pack into first four bytes of uint32_t 239| 295k| uint32_t packed{}; 240| 295k| packed |= (chunk & 0x0000000F); 241| 295k| packed |= (chunk & 0x00000F00) >> 4; 242| 295k| packed |= (chunk & 0x000F0000) >> 8; 243| 295k| packed |= (chunk & 0x0F000000) >> 12; 244| 295k| return packed; 245| 300k| } _ZN3glz20escape_prefix_intactILb1EccEEbPKT0_PKT1_: 329| 74| { 330| 74| auto n = size_t(end - it); 331| 74| if constexpr (ExpectOpener) { 332| 74| if (n > 0 && it[0] != '\\') return false; ------------------ | Branch (332:14): [True: 74, False: 0] | Branch (332:23): [True: 22, False: 52] ------------------ 333| 52| if (n > 1 && it[1] != 'u') return false; ------------------ | Branch (333:14): [True: 52, False: 0] | Branch (333:23): [True: 22, False: 30] ------------------ 334| 30| if (n < 2) return true; ------------------ | Branch (334:14): [True: 0, False: 30] ------------------ 335| 30| it += 2; 336| 30| n -= 2; 337| 30| } 338| 108| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (338:26): [True: 64, False: 44] ------------------ 339| 64| if (digit_hex_table[uint8_t(it[i])] == 255) return false; ------------------ | Branch (339:14): [True: 30, False: 34] ------------------ 340| 64| } 341| 44| return true; 342| 74| } _ZN3glz18code_point_to_utf8IcEEjjPT_: 249| 66.5k| { 250| 66.5k| if (code_point <= 0x7F) { ------------------ | Branch (250:11): [True: 867, False: 65.6k] ------------------ 251| 867| c[0] = Char(code_point); 252| 867| return 1; 253| 867| } 254| 65.6k| if (code_point <= 0x7FF) { ------------------ | Branch (254:11): [True: 57.3k, False: 8.35k] ------------------ 255| 57.3k| c[0] = Char(0xC0 | ((code_point >> 6) & 0x1F)); 256| 57.3k| c[1] = Char(0x80 | (code_point & 0x3F)); 257| 57.3k| return 2; 258| 57.3k| } 259| 8.35k| if (code_point <= 0xFFFF) { ------------------ | Branch (259:11): [True: 4.09k, False: 4.26k] ------------------ 260| 4.09k| c[0] = Char(0xE0 | ((code_point >> 12) & 0x0F)); 261| 4.09k| c[1] = Char(0x80 | ((code_point >> 6) & 0x3F)); 262| 4.09k| c[2] = Char(0x80 | (code_point & 0x3F)); 263| 4.09k| return 3; 264| 4.09k| } 265| 4.26k| if (code_point <= 0x10FFFF) { ------------------ | Branch (265:11): [True: 4.26k, False: 0] ------------------ 266| 4.26k| c[0] = Char(0xF0 | ((code_point >> 18) & 0x07)); 267| 4.26k| c[1] = Char(0x80 | ((code_point >> 12) & 0x3F)); 268| 4.26k| c[2] = Char(0x80 | ((code_point >> 6) & 0x3F)); 269| 4.26k| c[3] = Char(0x80 | (code_point & 0x3F)); 270| 4.26k| return 4; 271| 4.26k| } 272| 0| return 0; 273| 4.26k| } _ZN3glz17match_invalid_endILc91EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 470| 64.7k| { 471| 64.7k| if (*it != C) [[unlikely]] { ------------------ | Branch (471:11): [True: 212, False: 64.5k] ------------------ 472| | if constexpr (C == '"') { 473| | ctx.error = error_code::expected_quote; 474| | } 475| | else if constexpr (C == ',') { 476| | ctx.error = error_code::expected_comma; 477| | } 478| | else if constexpr (C == ':') { 479| | ctx.error = error_code::expected_colon; 480| | } 481| 212| else if constexpr (C == '[' || C == ']') { 482| 212| ctx.error = error_code::expected_bracket; 483| | } 484| | else if constexpr (C == '{' || C == '}') { 485| | ctx.error = error_code::expected_brace; 486| | } 487| | else { 488| | ctx.error = error_code::syntax_error; 489| | } 490| 212| return true; 491| 212| } 492| 64.5k| else [[likely]] { 493| 64.5k| ++it; 494| 64.5k| } 495| 64.5k| if constexpr (not Opts.null_terminated) { 496| 64.5k| if (it == end) [[unlikely]] { ------------------ | Branch (496:14): [True: 15, False: 64.5k] ------------------ 497| 15| ctx.error = error_code::unexpected_end; 498| 15| return true; 499| 15| } 500| 64.5k| } 501| 64.5k| return false; 502| 64.7k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 873| 3.46M| { 874| | if constexpr (not check_validate_utf8(Opts)) { 875| | // Everything the caller computed for us is dead, which lets its scan loop drop the 876| | // accumulator entirely. 877| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 878| | return false; 879| | } 880| 3.46M| else { 881| 3.46M| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (881:14): [True: 3.30M, False: 155k] ------------------ 882| 3.30M| return false; // pure ASCII is trivially well formed UTF-8 883| 3.30M| } 884| 155k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (884:14): [True: 37, False: 155k] ------------------ 885| 37| ctx.error = error_code::invalid_utf8; 886| 37| return true; 887| 37| } 888| 155k| return false; 889| 155k| } 890| 3.46M| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_EEvOT1_OT2_T3_: 539| 1.66k| { 540| 1.66k| static constexpr auto S = str.sv(); 541| 1.66k| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 381, False: 1.28k] | Branch (541:54): [True: 338, False: 945] ------------------ 542| 719| ctx.error = error_code::syntax_error; 543| 719| } 544| 945| else [[likely]] { 545| 945| it += str.size(); 546| 945| } 547| 1.66k| } _ZN3glz16skip_string_viewITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 965| 198k| { 966| 198k| uint64_t ascii_acc{}; 967| 198k| skip_string_view(ctx, it, end, ascii_acc); 968| 198k| } _ZN3glz5matchILc34ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 506| 54.3k| { 507| 54.3k| if (*it != C) [[unlikely]] { ------------------ | Branch (507:11): [True: 0, False: 54.3k] ------------------ 508| 0| if constexpr (C == '"') { 509| 0| ctx.error = error_code::expected_quote; 510| | } 511| | else if constexpr (C == ',') { 512| | ctx.error = error_code::expected_comma; 513| | } 514| | else if constexpr (C == ':') { 515| | ctx.error = error_code::expected_colon; 516| | } 517| | else if constexpr (C == '[' || C == ']') { 518| | ctx.error = error_code::expected_bracket; 519| | } 520| | else if constexpr (C == '{' || C == '}') { 521| | ctx.error = error_code::expected_brace; 522| | } 523| | else { 524| | ctx.error = error_code::syntax_error; 525| | } 526| 0| return true; 527| 0| } 528| 54.3k| else [[likely]] { 529| 54.3k| ++it; 530| 54.3k| return false; 531| 54.3k| } 532| 54.3k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextERPKcS8_EEvOT1_OT2_T3_: 539| 887| { 540| 887| static constexpr auto S = str.sv(); 541| 887| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 16, False: 871] | Branch (541:54): [True: 217, False: 654] ------------------ 542| 233| ctx.error = error_code::syntax_error; 543| 233| } 544| 654| else [[likely]] { 545| 654| it += str.size(); 546| 654| } 547| 887| } _ZN3glz11skip_numberIXtlNS_16skip_number_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1633| 73.6k| { 1634| 73.6k| if constexpr (not Opts.validate) { 1635| | if constexpr (Opts.null_terminated) { 1636| | // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate. 1637| | while (numeric_table[uint8_t(*it)]) { 1638| | ++it; 1639| | } 1640| | } 1641| 73.6k| else { 1642| 16.7M| while (it < end && numeric_table[uint8_t(*it)]) { ------------------ | Branch (1642:20): [True: 16.7M, False: 50] | Branch (1642:32): [True: 16.6M, False: 73.6k] ------------------ 1643| 16.6M| ++it; 1644| 16.6M| } 1645| 73.6k| } 1646| | } 1647| | else { 1648| | skip_number_with_validation(ctx, it, end); 1649| | } 1650| 73.6k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc110ELc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_EEvOT1_OT2_T3_: 539| 516k| { 540| 516k| static constexpr auto S = str.sv(); 541| 516k| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 209, False: 516k] | Branch (541:54): [True: 599, False: 515k] ------------------ 542| 808| ctx.error = error_code::syntax_error; 543| 808| } 544| 515k| else [[likely]] { 545| 515k| it += str.size(); 546| 515k| } 547| 516k| } _ZN3glz5matchILc125ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 506| 54.3k| { 507| 54.3k| if (*it != C) [[unlikely]] { ------------------ | Branch (507:11): [True: 8.55k, False: 45.7k] ------------------ 508| | if constexpr (C == '"') { 509| | ctx.error = error_code::expected_quote; 510| | } 511| | else if constexpr (C == ',') { 512| | ctx.error = error_code::expected_comma; 513| | } 514| | else if constexpr (C == ':') { 515| | ctx.error = error_code::expected_colon; 516| | } 517| | else if constexpr (C == '[' || C == ']') { 518| | ctx.error = error_code::expected_bracket; 519| | } 520| 8.55k| else if constexpr (C == '{' || C == '}') { 521| 8.55k| ctx.error = error_code::expected_brace; 522| | } 523| | else { 524| | ctx.error = error_code::syntax_error; 525| | } 526| 8.55k| return true; 527| 8.55k| } 528| 45.7k| else [[likely]] { 529| 45.7k| ++it; 530| 45.7k| return false; 531| 45.7k| } 532| 54.3k| } _ZN3glz5matchILc93ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 506| 24.3k| { 507| 24.3k| if (*it != C) [[unlikely]] { ------------------ | Branch (507:11): [True: 2.32k, False: 22.0k] ------------------ 508| | if constexpr (C == '"') { 509| | ctx.error = error_code::expected_quote; 510| | } 511| | else if constexpr (C == ',') { 512| | ctx.error = error_code::expected_comma; 513| | } 514| | else if constexpr (C == ':') { 515| | ctx.error = error_code::expected_colon; 516| | } 517| 2.32k| else if constexpr (C == '[' || C == ']') { 518| 2.32k| ctx.error = error_code::expected_bracket; 519| | } 520| | else if constexpr (C == '{' || C == '}') { 521| | ctx.error = error_code::expected_brace; 522| | } 523| | else { 524| | ctx.error = error_code::syntax_error; 525| | } 526| 2.32k| return true; 527| 2.32k| } 528| 22.0k| else [[likely]] { 529| 22.0k| ++it; 530| 22.0k| return false; 531| 22.0k| } 532| 24.3k| } _ZN3glz11skip_stringIXtlNS_16skip_string_optsELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1012| 282k| { 1013| 282k| if constexpr (not Opts.opening_handled) { 1014| 282k| ++it; 1015| 282k| } 1016| | 1017| 282k| const auto* const utf8_start = it; 1018| | 1019| 282k| if constexpr (Opts.validate_skipped) { 1020| | // The bound as a pointer, so each chunk costs one compare. `end - scan_min` is only a 1021| | // pointer into the buffer once at least that much of it is left, and a string can start 1022| | // within a few bytes of the end; where it is not, the fallback is the opening quote, which 1023| | // sits before `it` and so fails the test on the first look. Never `it` itself -- that 1024| | // passes, and the chunk behind it would read past the end of the buffer. 1025| 282k| const std::ptrdiff_t scan_min = chunk_min<8>(ctx.padded_input); 1026| 282k| const auto* const chunk_limit = (end - it >= scan_min) ? end - scan_min : it - 1; ------------------ | Branch (1026:42): [True: 252k, False: 30.0k] ------------------ 1027| | 1028| 7.87M| while (it <= chunk_limit) { ------------------ | Branch (1028:17): [True: 7.83M, False: 39.9k] ------------------ 1029| 7.83M| uint64_t swar; 1030| 7.83M| std::memcpy(&swar, it, 8); 1031| | if constexpr (std::endian::native == std::endian::big) { 1032| | swar = std::byteswap(swar); 1033| | } 1034| | 1035| 7.83M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1036| 7.83M| const uint64_t lo7 = swar & lo7_mask; 1037| 7.83M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1038| 7.83M| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 1039| 7.83M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1040| 7.83M| uint64_t next = ~((backslash & quote & less_32) | swar); 1041| 7.83M| next &= repeat_byte8(0b10000000); 1042| | 1043| 7.83M| if (next == 0) { ------------------ | Branch (1043:17): [True: 7.25M, False: 574k] ------------------ 1044| | // No special characters in this chunk 1045| 7.25M| it += 8; 1046| 7.25M| continue; 1047| 7.25M| } 1048| | 1049| | // Find the first occurrence 1050| 574k| size_t offset = (countr_zero(next) >> 3); 1051| 574k| it += offset; 1052| | 1053| 574k| const auto c = *it; 1054| 574k| if ((c & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1054:17): [True: 3.07k, False: 571k] ------------------ 1055| | // Invalid control character (<0x20) 1056| 3.07k| ctx.error = error_code::syntax_error; 1057| 3.07k| return; 1058| 3.07k| } 1059| 571k| else if (c == '"') { ------------------ | Branch (1059:22): [True: 225k, False: 346k] ------------------ 1060| | // Check if this quote is escaped 1061| 225k| const auto* p = it - 1; 1062| 225k| int backslash_count{}; 1063| | // We don't have to worry about rewinding too far because we started with a quote 1064| 248k| while (*p == '\\') { ------------------ | Branch (1064:23): [True: 23.1k, False: 225k] ------------------ 1065| 23.1k| ++backslash_count; 1066| 23.1k| --p; 1067| 23.1k| } 1068| 225k| if ((backslash_count & 1) == 0) { ------------------ | Branch (1068:20): [True: 225k, False: 0] ------------------ 1069| | // Even number of backslashes => not escaped => closing quote found 1070| 225k| validate_utf8_span(ctx, utf8_start, it); 1071| 225k| ++it; 1072| 225k| return; 1073| 225k| } 1074| 0| else { 1075| | // Odd number of backslashes => escaped quote 1076| 0| ++it; 1077| 0| continue; 1078| 0| } 1079| 225k| } 1080| 346k| else if (c == '\\') { ------------------ | Branch (1080:22): [True: 346k, False: 0] ------------------ 1081| | // Handle escape sequence 1082| 346k| ++it; 1083| | 1084| | // The backslash can be the last byte the chunk covers, which lands `it` on `end`. 1085| | // A null-terminated buffer answers that read with its terminator, which the escape 1086| | // table below rejects; a bounded one has nothing there to read. 1087| 346k| if constexpr (not Opts.null_terminated) { 1088| 346k| if (it == end) [[unlikely]] { ------------------ | Branch (1088:23): [True: 6, False: 346k] ------------------ 1089| 6| ctx.error = error_code::unexpected_end; 1090| 6| return; 1091| 6| } 1092| 346k| } 1093| | 1094| 346k| if (*it == 'u') { ------------------ | Branch (1094:20): [True: 219k, False: 126k] ------------------ 1095| 219k| ++it; 1096| 219k| if (not skip_unicode_code_point(it, end)) [[unlikely]] { ------------------ | Branch (1096:23): [True: 12.9k, False: 206k] ------------------ 1097| 12.9k| ctx.error = error_code::unicode_escape_conversion_failure; 1098| 12.9k| return; 1099| 12.9k| } 1100| 219k| } 1101| 126k| else { 1102| 126k| if (not char_unescape_table[uint8_t(*it)]) [[unlikely]] { ------------------ | Branch (1102:23): [True: 1.58k, False: 124k] ------------------ 1103| 1.58k| ctx.error = error_code::invalid_escape; 1104| 1.58k| return; 1105| 1.58k| } 1106| 124k| ++it; 1107| 124k| } 1108| 346k| } 1109| 574k| } 1110| | 1111| 85.8k| while (true) { ------------------ | Branch (1111:17): [True: 85.8k, Folded] ------------------ 1112| | // A null-terminated buffer terminates on the trailing '\0' (caught by the control 1113| | // character check below); a non-null-terminated buffer has no sentinel, so bound the 1114| | // scan before each dereference. 1115| 85.8k| if constexpr (not Opts.null_terminated) { 1116| 85.8k| if (it == end) [[unlikely]] { ------------------ | Branch (1116:20): [True: 306, False: 85.5k] ------------------ 1117| 306| ctx.error = error_code::unexpected_end; 1118| 306| return; 1119| 306| } 1120| 85.8k| } 1121| 85.8k| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1121:17): [True: 1.86k, False: 84.0k] ------------------ 1122| 1.86k| ctx.error = error_code::syntax_error; 1123| 1.86k| return; 1124| 1.86k| } 1125| | 1126| 84.0k| switch (*it) { ------------------ | Branch (1126:21): [True: 45.7k, False: 38.2k] ------------------ 1127| 32.5k| case '"': { ------------------ | Branch (1127:13): [True: 32.5k, False: 51.4k] ------------------ 1128| 32.5k| validate_utf8_span(ctx, utf8_start, it); 1129| 32.5k| ++it; 1130| 32.5k| return; 1131| 0| } 1132| 13.2k| case '\\': { ------------------ | Branch (1132:13): [True: 13.2k, False: 70.7k] ------------------ 1133| 13.2k| ++it; 1134| 13.2k| if constexpr (not Opts.null_terminated) { 1135| 13.2k| if (it == end) [[unlikely]] { ------------------ | Branch (1135:23): [True: 15, False: 13.2k] ------------------ 1136| 15| ctx.error = error_code::unexpected_end; 1137| 15| return; 1138| 15| } 1139| 13.2k| } 1140| 13.2k| if (char_unescape_table[uint8_t(*it)]) { ------------------ | Branch (1140:20): [True: 7.12k, False: 6.13k] ------------------ 1141| 7.12k| ++it; 1142| 7.12k| continue; 1143| 7.12k| } 1144| 6.13k| else if (*it == 'u') { ------------------ | Branch (1144:25): [True: 4.84k, False: 1.29k] ------------------ 1145| 4.84k| ++it; 1146| 4.84k| if (skip_unicode_code_point(it, end)) [[likely]] { ------------------ | Branch (1146:23): [True: 856, False: 3.98k] ------------------ 1147| 856| continue; 1148| 856| } 1149| 3.98k| else [[unlikely]] { 1150| 3.98k| ctx.error = error_code::unicode_escape_conversion_failure; 1151| 3.98k| return; 1152| 3.98k| } 1153| 4.84k| } 1154| | // Same code the chunked loop above reports. Both loops run over one buffer now, so 1155| | // an escape that lands in the last few bytes must be diagnosed the same as one that 1156| | // does not. 1157| 1.29k| ctx.error = error_code::invalid_escape; 1158| 1.29k| return; 1159| 13.2k| } 1160| 84.0k| } 1161| 37.9k| ++it; 1162| 37.9k| } 1163| | } 1164| | else { 1165| | uint64_t ascii_acc{}; 1166| | skip_string_view(ctx, it, end, ascii_acc); 1167| | if (bool(ctx.error)) [[unlikely]] { 1168| | return; 1169| | } 1170| | if (validate_utf8_span(ctx, utf8_start, it, ascii_acc)) [[unlikely]] { 1171| | return; 1172| | } 1173| | ++it; // skip the quote 1174| | } 1175| 282k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_16skip_string_optsELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 873| 257k| { 874| | if constexpr (not check_validate_utf8(Opts)) { 875| | // Everything the caller computed for us is dead, which lets its scan loop drop the 876| | // accumulator entirely. 877| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 878| | return false; 879| | } 880| 257k| else { 881| 257k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (881:14): [True: 0, False: 257k] ------------------ 882| 0| return false; // pure ASCII is trivially well formed UTF-8 883| 0| } 884| 257k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (884:14): [True: 788, False: 257k] ------------------ 885| 788| ctx.error = error_code::invalid_utf8; 886| 788| return true; 887| 788| } 888| 257k| return false; 889| 257k| } 890| 257k| } _ZN3glz23skip_unicode_code_pointIcEEbRPKT_S3_: 402| 224k| { 403| 224k| using namespace unicode; 404| 224k| if (it + 4 >= end) [[unlikely]] { ------------------ | Branch (404:11): [True: 5.64k, False: 218k] ------------------ 405| 5.64k| return false; 406| 5.64k| } 407| | 408| 218k| const uint32_t high = hex_to_u32(it); 409| 218k| if (high == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (409:11): [True: 3.72k, False: 215k] ------------------ 410| 3.72k| return false; 411| 3.72k| } 412| 215k| it += 4; // skip the code point characters 413| | 414| 215k| uint32_t code_point; 415| | 416| 215k| if ((high & generic_surrogate_mask) == generic_surrogate_value) { ------------------ | Branch (416:11): [True: 15.2k, False: 199k] ------------------ 417| | // surrogate pair code points 418| 15.2k| if ((high & surrogate_mask) != high_surrogate_value) [[unlikely]] { ------------------ | Branch (418:14): [True: 1.65k, False: 13.6k] ------------------ 419| 1.65k| return false; 420| 1.65k| } 421| | 422| 13.6k| if (it + 6 >= end) [[unlikely]] { ------------------ | Branch (422:14): [True: 1.47k, False: 12.1k] ------------------ 423| 1.47k| return false; 424| 1.47k| } 425| | // The next two characters must be `\u` 426| 12.1k| uint16_t u; 427| 12.1k| std::memcpy(&u, it, 2); 428| 12.1k| if (u != to_uint16_t(R"(\u)")) [[unlikely]] { ------------------ | Branch (428:14): [True: 1.84k, False: 10.3k] ------------------ 429| 1.84k| return false; 430| 1.84k| } 431| 10.3k| it += 2; 432| | // verify that second unicode escape sequence is present 433| 10.3k| const uint32_t low = hex_to_u32(it); 434| 10.3k| if (low == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (434:14): [True: 1.58k, False: 8.73k] ------------------ 435| 1.58k| return false; 436| 1.58k| } 437| 8.73k| it += 4; 438| | 439| 8.73k| if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] { ------------------ | Branch (439:14): [True: 1.00k, False: 7.72k] ------------------ 440| 1.00k| return false; 441| 1.00k| } 442| | 443| 7.72k| code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits; 444| 7.72k| code_point |= (low & surrogate_codepoint_mask); 445| 7.72k| code_point += surrogate_codepoint_offset; 446| 7.72k| } 447| 199k| else { 448| 199k| code_point = high; 449| 199k| } 450| 207k| return skip_code_point(code_point) > 0; 451| 215k| } _ZN3glz15skip_code_pointEj: 276| 207k| { 277| 207k| if (code_point <= 0x7F) { ------------------ | Branch (277:11): [True: 9.17k, False: 198k] ------------------ 278| 9.17k| return 1; 279| 9.17k| } 280| 198k| if (code_point <= 0x7FF) { ------------------ | Branch (280:11): [True: 167k, False: 30.7k] ------------------ 281| 167k| return 2; 282| 167k| } 283| 30.7k| if (code_point <= 0xFFFF) { ------------------ | Branch (283:11): [True: 23.0k, False: 7.72k] ------------------ 284| 23.0k| return 3; 285| 23.0k| } 286| 7.72k| if (code_point <= 0x10FFFF) { ------------------ | Branch (286:11): [True: 7.72k, False: 0] ------------------ 287| 7.72k| return 4; 288| 7.72k| } 289| 0| return 0; 290| 7.72k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEvOT1_OT2_T3_: 539| 4.44k| { 540| 4.44k| static constexpr auto S = str.sv(); 541| 4.44k| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 832, False: 3.61k] | Branch (541:54): [True: 1.32k, False: 2.29k] ------------------ 542| 2.15k| ctx.error = error_code::syntax_error; 543| 2.15k| } 544| 2.29k| else [[likely]] { 545| 2.29k| it += str.size(); 546| 2.29k| } 547| 4.44k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEvOT1_OT2_T3_: 539| 9.08k| { 540| 9.08k| static constexpr auto S = str.sv(); 541| 9.08k| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 1.96k, False: 7.11k] | Branch (541:54): [True: 1.42k, False: 5.69k] ------------------ 542| 3.39k| ctx.error = error_code::syntax_error; 543| 3.39k| } 544| 5.69k| else [[likely]] { 545| 5.69k| it += str.size(); 546| 5.69k| } 547| 9.08k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlNS_22registry_validate_optsIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEtlS5_Lj10ELb0ELb0ELb1ELb1EELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcSA_EEvOT1_OT2_T3_: 539| 3.17k| { 540| 3.17k| static constexpr auto S = str.sv(); 541| 3.17k| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 744, False: 2.43k] | Branch (541:54): [True: 884, False: 1.54k] ------------------ 542| 1.62k| ctx.error = error_code::syntax_error; 543| 1.62k| } 544| 1.54k| else [[likely]] { 545| 1.54k| it += str.size(); 546| 1.54k| } 547| 3.17k| } _ZN3glz11skip_numberIXtlNS_16skip_number_optsELb1EEETkNS_10is_contextERNS_7contextERPKcS5_EEvOT0_OT1_T2_: 1633| 552k| { 1634| | if constexpr (not Opts.validate) { 1635| | if constexpr (Opts.null_terminated) { 1636| | // Relies on the trailing '\0' sentinel (numeric_table['\0'] == false) to terminate. 1637| | while (numeric_table[uint8_t(*it)]) { 1638| | ++it; 1639| | } 1640| | } 1641| | else { 1642| | while (it < end && numeric_table[uint8_t(*it)]) { 1643| | ++it; 1644| | } 1645| | } 1646| | } 1647| 552k| else { 1648| 552k| skip_number_with_validation(ctx, it, end); 1649| 552k| } 1650| 552k| } _ZN3glz27skip_number_with_validationITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 1560| 552k| { 1561| | // Every standalone *it read below is guarded by it != end so the scan stays inside the 1562| | // buffer for non-null-terminated input (the std::find_if_not calls are already bounded by 1563| | // end). A null-terminated buffer is unaffected: it reaches end only once the number is 1564| | // fully consumed, where these guards short-circuit exactly as the trailing '\0' sentinel 1565| | // would have. 1566| 552k| it += (it != end) && (*it == '-'); ------------------ | Branch (1566:13): [True: 552k, False: 0] | Branch (1566:28): [True: 104k, False: 448k] ------------------ 1567| 552k| const auto sig_start_it = it; 1568| 552k| auto frac_start_it = end; 1569| 552k| if (it != end && *it == '0') { ------------------ | Branch (1569:11): [True: 548k, False: 4.03k] | Branch (1569:24): [True: 76.2k, False: 472k] ------------------ 1570| 76.2k| ++it; 1571| | // RFC 8259 section 6: number = [ minus ] int [ frac ] [ exp ]. The exponent may follow 1572| | // the integer part directly, with no fractional part in between (e.g. "0e4"). 1573| 76.2k| if (it != end && (*it | ('E' ^ 'e')) == 'e') { ------------------ | Branch (1573:14): [True: 70.6k, False: 5.63k] | Branch (1573:27): [True: 29.7k, False: 40.9k] ------------------ 1574| 29.7k| ++it; 1575| 29.7k| goto exp_start; 1576| 29.7k| } 1577| 46.5k| if (it == end || *it != '.') { ------------------ | Branch (1577:14): [True: 5.63k, False: 40.9k] | Branch (1577:27): [True: 35.0k, False: 5.93k] ------------------ 1578| 40.6k| return; 1579| 40.6k| } 1580| 5.93k| ++it; 1581| 5.93k| goto frac_start; 1582| 46.5k| } 1583| 476k| it = std::find_if_not(it, end, is_digit); 1584| 476k| if (it == sig_start_it) { ------------------ | Branch (1584:11): [True: 80.2k, False: 395k] ------------------ 1585| 80.2k| ctx.error = error_code::syntax_error; 1586| 80.2k| return; 1587| 80.2k| } 1588| 395k| if (it != end && (*it | ('E' ^ 'e')) == 'e') { ------------------ | Branch (1588:11): [True: 373k, False: 22.4k] | Branch (1588:24): [True: 16.2k, False: 357k] ------------------ 1589| 16.2k| ++it; 1590| 16.2k| goto exp_start; 1591| 16.2k| } 1592| 379k| if (it == end || *it != '.') return; ------------------ | Branch (1592:11): [True: 22.4k, False: 357k] | Branch (1592:24): [True: 342k, False: 14.8k] ------------------ 1593| 14.8k| ++it; 1594| 20.7k| frac_start: 1595| 20.7k| frac_start_it = it; 1596| 20.7k| it = std::find_if_not(it, end, is_digit); 1597| 20.7k| if (it == frac_start_it) { ------------------ | Branch (1597:11): [True: 1.01k, False: 19.7k] ------------------ 1598| 1.01k| ctx.error = error_code::syntax_error; 1599| 1.01k| return; 1600| 1.01k| } 1601| 19.7k| if (it == end || (*it | ('E' ^ 'e')) != 'e') return; ------------------ | Branch (1601:11): [True: 1.93k, False: 17.8k] | Branch (1601:24): [True: 14.3k, False: 3.47k] ------------------ 1602| 3.47k| ++it; 1603| 49.4k| exp_start: 1604| 49.4k| it += (it != end) && (*it == '+' || *it == '-'); ------------------ | Branch (1604:13): [True: 48.7k, False: 639] | Branch (1604:29): [True: 5.22k, False: 43.5k] | Branch (1604:43): [True: 1.86k, False: 41.6k] ------------------ 1605| 49.4k| const auto exp_start_it = it; 1606| 49.4k| it = std::find_if_not(it, end, is_digit); 1607| 49.4k| if (it == exp_start_it) { ------------------ | Branch (1607:11): [True: 1.90k, False: 47.5k] ------------------ 1608| 1.90k| ctx.error = error_code::syntax_error; 1609| 1.90k| return; 1610| 1.90k| } 1611| 49.4k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_EEvSE_OSF_T3_: 539| 802| { 540| 802| static constexpr auto S = str.sv(); 541| 802| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 0, False: 802] | Branch (541:54): [True: 0, False: 802] ------------------ 542| 0| ctx.error = error_code::syntax_error; 543| 0| } 544| 802| else [[likely]] { 545| 802| it += str.size(); 546| 802| } 547| 802| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm5EEEtlA5_cLc97ELc108ELc115ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_EEvSE_OSF_T3_: 539| 787| { 540| 787| static constexpr auto S = str.sv(); 541| 787| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 0, False: 787] | Branch (541:54): [True: 0, False: 787] ------------------ 542| 0| ctx.error = error_code::syntax_error; 543| 0| } 544| 787| else [[likely]] { 545| 787| it += str.size(); 546| 787| } 547| 787| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc114ELc117ELc101EEEETnDaXtlZNS_11parse_valueITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_EEDaOT0_OT1_T2_E21opts_validate_skippedtlS5_Lj10ELb0ELb0ELb1ELb1EELb1EEETkNS_10is_contextES7_SA_S9_EEvSE_OSF_T3_: 539| 972| { 540| 972| static constexpr auto S = str.sv(); 541| 972| if ((end - it < std::ptrdiff_t(str.size())) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (541:11): [True: 0, False: 972] | Branch (541:54): [True: 0, False: 972] ------------------ 542| 0| ctx.error = error_code::syntax_error; 543| 0| } 544| 972| else [[likely]] { 545| 972| it += str.size(); 546| 972| } 547| 972| } _ZNK3glz14string_literalILm4EE4sizeEv: 25| 17.6k| [[nodiscard]] constexpr size_t size() const noexcept { return length; } _ZNK3glz14string_literalILm5EE4sizeEv: 25| 1.04M| [[nodiscard]] constexpr size_t size() const noexcept { return length; } _ZN3glz6detail15get_source_infoITkNS_10contiguousENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS0_11source_infoERKT_m: 42| 4.28M| { 43| 4.28M| using V = std::decay_t; 44| | 45| | if constexpr (std::same_as) { 46| | return {.context = "", .index = index}; 47| | } 48| 4.28M| else { 49| 4.28M| const std::string_view text{reinterpret_cast(buffer.data()), buffer.size()}; 50| 4.28M| if (index >= text.size()) { ------------------ | Branch (50:17): [True: 4.01M, False: 273k] ------------------ 51| 4.01M| return {.context = "", .index = index}; 52| 4.01M| } 53| | 54| | // The line the error sits on starts just after the newline before it, or at the 55| | // beginning when there is none. Both the column and the context start from that one 56| | // position. Searching from index - 1 leaves index itself out, so a newline *at* the 57| | // error belongs to the line it ends rather than the one it opens. 58| 273k| const size_t prev_newline = index ? text.rfind('\n', index - 1) : text.npos; ------------------ | Branch (58:41): [True: 110k, False: 162k] ------------------ 59| 273k| const size_t offset = (prev_newline == text.npos) ? 0 : prev_newline + 1; ------------------ | Branch (59:35): [True: 266k, False: 7.06k] ------------------ 60| 273k| const size_t column = index - offset + 1; 61| 273k| const size_t line = size_t(std::count(text.begin(), text.begin() + index, '\n') + 1); 62| | 63| 273k| size_t context_begin = offset; 64| 273k| size_t context_end = (std::min)(text.find('\n', index + 1), text.size()); 65| | 66| 273k| size_t front_truncation = 0; 67| 273k| size_t rear_truncation = 0; 68| | 69| 273k| if (context_end - context_begin > 64) { ------------------ | Branch (69:17): [True: 32.2k, False: 241k] ------------------ 70| | // reduce the context length so that we can more easily see errors, especially for non-prettified buffers 71| 32.2k| if (column <= 32) { ------------------ | Branch (71:20): [True: 12.8k, False: 19.4k] ------------------ 72| 12.8k| rear_truncation = 64; 73| 12.8k| context_end = context_begin + rear_truncation; 74| 12.8k| } 75| 19.4k| else { 76| 19.4k| front_truncation = column - 32; 77| 19.4k| context_begin += front_truncation; 78| 19.4k| if (context_end - context_begin > 64) { ------------------ | Branch (78:23): [True: 11.1k, False: 8.20k] ------------------ 79| 11.1k| rear_truncation = front_truncation + 64; 80| 11.1k| context_end = offset + rear_truncation; 81| 11.1k| } 82| 19.4k| } 83| 32.2k| } 84| | 85| 273k| std::string context{text.substr(context_begin, context_end - context_begin)}; 86| 273k| convert_tabs_to_single_spaces(context); 87| 273k| return {line, column, context, index, front_truncation, rear_truncation}; 88| 4.28M| } 89| 4.28M| } _ZN3glz6detail29convert_tabs_to_single_spacesERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 31| 273k| { 32| 4.74M| for (auto& c : input) { ------------------ | Branch (32:23): [True: 4.74M, False: 273k] ------------------ 33| 4.74M| if (c == '\t') { ------------------ | Branch (33:17): [True: 48.2k, False: 4.69M] ------------------ 34| 48.2k| c = ' '; 35| 48.2k| } 36| 4.74M| } 37| 273k| } _ZN3glz6detail21generate_error_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS0_11source_infoES5_: 110| 4.28M| { 111| 4.28M| std::string b{}; 112| 4.28M| b.resize(error.size() + info.context.size() + filename.size() + 128); 113| 4.28M| size_t ix{}; 114| | 115| 4.28M| if (not filename.empty()) { ------------------ | Branch (115:14): [True: 0, False: 4.28M] ------------------ 116| 0| dump_not_empty(filename, b, ix); 117| 0| dump(':', b, ix); 118| 0| } 119| | 120| 4.28M| glz::context ctx{}; 121| | 122| | // Diagnostic numbers (index/line/column) are always formatted with size-optimized 123| | // integer conversion: error formatting is never a throughput path, and this keeps 124| | // glz::format_error from pulling in the 40 KB integer table regardless of the 125| | // optimization level used elsewhere in the program. 126| 4.28M| if (info.context.empty()) { ------------------ | Branch (126:14): [True: 4.01M, False: 273k] ------------------ 127| 4.01M| dump("index ", b, ix); 128| 4.01M| write_chars::op(info.index, ctx, b, ix); 129| 4.01M| dump(": ", b, ix); 130| 4.01M| dump_maybe_empty(error, b, ix); 131| 4.01M| } 132| 273k| else { 133| 273k| write_chars::op(info.line, ctx, b, ix); 134| 273k| dump(':', b, ix); 135| 273k| write_chars::op(info.column, ctx, b, ix); 136| 273k| dump(": ", b, ix); 137| 273k| dump_maybe_empty(error, b, ix); 138| 273k| dump('\n', b, ix); 139| 273k| if (info.front_truncation) { ------------------ | Branch (139:17): [True: 19.4k, False: 254k] ------------------ 140| 19.4k| if (info.rear_truncation) { ------------------ | Branch (140:20): [True: 11.1k, False: 8.20k] ------------------ 141| 11.1k| dump("...", b, ix); 142| 11.1k| dump_maybe_empty(info.context, b, ix); 143| 11.1k| dump("...\n ", b, ix); 144| 11.1k| } 145| 8.20k| else { 146| 8.20k| dump("...", b, ix); 147| 8.20k| dump_maybe_empty(info.context, b, ix); 148| 8.20k| dump("\n ", b, ix); 149| 8.20k| } 150| 19.4k| } 151| 254k| else { 152| 254k| dump(" ", b, ix); 153| 254k| dump_maybe_empty(info.context, b, ix); 154| 254k| dump("\n ", b, ix); 155| 254k| } 156| 273k| dumpn(' ', info.column - 1 - info.front_truncation, b, ix); 157| 273k| dump('^', b, ix); 158| 273k| } 159| | 160| 4.28M| b.resize(ix); 161| 4.28M| return b; 162| 4.28M| } _ZN3glz8to_charsITkNSt3__114floating_pointEdLb0EEEPcS2_T_: 1118| 2.77k| { 1119| 2.77k| static_assert(std::is_same_v || std::is_same_v); 1120| 2.77k| return zmij::detail::write(val, buf); 1121| 2.77k| } _ZN3glz4zmij6detail5writeIdLb0EEEPcT_S3_: 975| 2.77k| { 976| 2.77k| using namespace detail_impl; 977| 2.77k| using traits = float_traits; 978| 2.77k| auto bits = traits::to_bits(value); 979| 2.77k| auto bin_exp = traits::get_exp(bits); 980| 2.77k| auto bin_sig = traits::get_sig(bits); 981| | 982| 2.77k| *buffer = '-'; 983| 2.77k| buffer += traits::is_negative(bits); 984| | 985| 2.77k| const auto* c = &consts_v; 986| 2.77k| ZMIJ_ASM(("" : "+r"(c))); ------------------ | | 126| 2.77k|#define ZMIJ_ASM(x) asm x ------------------ 987| 2.77k| int64_t threshold = traits::num_bits == 64 ? static_cast(c->threshold) : 10'000'000; ------------------ | Branch (987:30): [True: 2.77k, Folded] ------------------ 988| | 989| 2.77k| to_decimal_result dec; 990| 2.77k| bool is_normal = unsigned(bin_exp - 1) < unsigned(traits::exp_mask - 1); 991| 2.77k| if (!is_normal) [[unlikely]] { ------------------ | Branch (991:14): [True: 1.15k, False: 1.62k] ------------------ 992| 1.15k| if (bin_exp != 0) { ------------------ | Branch (992:17): [True: 0, False: 1.15k] ------------------ 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.15k| if (bin_sig == 0) { ------------------ | Branch (1004:17): [True: 725, False: 428] ------------------ 1005| 725| memcpy(buffer, "0", 2); 1006| 725| return buffer + 1; 1007| 725| } 1008| 428| dec = detail_impl::to_decimal(bin_sig, 1, true, *c); 1009| 428| int64_t dec_sig = dec.sig * 10 + (dec.has_last_digit ? dec.last_digit : 0); ------------------ | Branch (1009:47): [True: 51, False: 377] ------------------ 1010| 428| int32_t dec_exp = dec.exp; 1011| 2.14k| while (dec_sig < threshold) { ------------------ | Branch (1011:20): [True: 1.71k, False: 428] ------------------ 1012| 1.71k| dec_sig *= 10; 1013| 1.71k| --dec_exp; 1014| 1.71k| } 1015| 428| int64_t d = static_cast(detail_impl::div10(static_cast(dec_sig))); 1016| 428| int32_t last_digit = static_cast(dec_sig - d * 10); 1017| 428| dec = {d, dec_exp, last_digit, last_digit != 0}; 1018| 428| } 1019| 1.62k| else { 1020| 1.62k| dec = detail_impl::to_decimal(bin_sig | traits::implicit_bit, 1021| 1.62k| bin_exp, bin_sig != 0, *c); 1022| 1.62k| } 1023| 2.05k| bool extra_digit = dec.sig >= threshold; 1024| 2.05k| int dec_exp = dec.exp + traits::max_digits10 - 2 + extra_digit; 1025| 2.05k| if (traits::num_bits == 32 && dec.sig < 1'000'000) [[unlikely]] { ------------------ | Branch (1025:14): [Folded, False: 2.05k] | 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.05k| char* start = buffer; 1032| 2.05k| auto dig = to_digits(static_cast(dec.sig), extra_digit, *c); 1033| 2.05k| constexpr int bcd_size = traits::num_bits == 64 ? 16 : 8; ------------------ | Branch (1033:35): [True: 0, Folded] ------------------ 1034| 2.05k| if (dec_exp >= traits::min_fixed_dec_exp && dec_exp <= traits::max_fixed_dec_exp) { ------------------ | Branch (1034:14): [True: 1.51k, False: 538] | Branch (1034:54): [True: 837, False: 676] ------------------ 1035| 837| memcpy(start, &zeros_v, 8); 1036| 837| const auto& fmt = dec_exp_formats.get(dec_exp); 1037| 837| buffer += fmt.start_pos; 1038| 837| memcpy(buffer, &dig.digits, bcd_size); 1039| 837| memmove(buffer, buffer + !extra_digit, bcd_size); 1040| 837| buffer[bcd_size + extra_digit - 1] = static_cast('0' + (dec.has_last_digit ? dec.last_digit : 0)); ------------------ | Branch (1040:75): [True: 162, False: 675] ------------------ 1041| 837| memmove(start + fmt.shift_pos, start + fmt.point_pos, bcd_size); 1042| 837| start[fmt.point_pos] = '.'; 1043| 837| int num_digits = dec.has_last_digit ? bcd_size : dig.num_digits - 1; ------------------ | Branch (1043:30): [True: 162, False: 675] ------------------ 1044| 837| return buffer + fmt.exp_pos[num_digits + extra_digit - 1]; 1045| 837| } 1046| 1.21k| buffer += extra_digit; 1047| 1.21k| memcpy(buffer, &dig.digits, bcd_size); 1048| 1.21k| buffer[bcd_size] = static_cast('0' + dec.last_digit); 1049| 1.21k| buffer += dec.has_last_digit ? bcd_size + 1 : dig.num_digits; ------------------ | Branch (1049:20): [True: 382, False: 832] ------------------ 1050| 1.21k| start[0] = start[1]; 1051| 1.21k| start[1] = '.'; 1052| 1.21k| buffer -= (buffer - 1 == start + 1); 1053| | 1054| 1.21k| if constexpr (exp_string_table::enable) { 1055| 1.21k| uint64_t exp_data = exp_strings_v.data[dec_exp + exp_string_table::offset]; 1056| 1.21k| int len = int(exp_data >> 48); 1057| 1.21k| if (is_big_endian) exp_data = bswap64(exp_data); ------------------ | Branch (1057:17): [Folded, False: 1.21k] ------------------ 1058| 1.21k| memcpy(buffer, &exp_data, traits::max_exponent10 >= 100 ? 8 : 4); ------------------ | Branch (1058:39): [True: 1.21k, Folded] ------------------ 1059| 1.21k| return buffer + len; 1060| 1.21k| } 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.21k| buffer[0] = 'E'; 1067| 1.21k| buffer[1] = '-'; 1068| 1.21k| buffer += 1 + unsigned(neg); 1069| 1.21k| dec_exp = neg ? -dec_exp : dec_exp; ------------------ | Branch (1069:20): [True: 0, False: 1.21k] ------------------ 1070| 1.21k| unsigned hundreds_written = 0; 1071| 1.21k| if constexpr (traits::max_exponent10 >= 100) { 1072| 1.21k| int32_t digit = 0; 1073| | if constexpr (use_umul128_hi64) { 1074| | digit = static_cast(umul128_hi64(static_cast(dec_exp), 0x290000000000000ull)); 1075| | } 1076| 1.21k| else { 1077| 1.21k| digit = static_cast((uint32_t(dec_exp) * div100_sig) >> div100_exp); 1078| 1.21k| } 1079| 1.21k| *buffer = static_cast('0' + digit); 1080| 1.21k| hundreds_written = unsigned(dec_exp >= 100); 1081| 1.21k| buffer += hundreds_written; 1082| 1.21k| dec_exp -= digit * 100; 1083| 1.21k| } 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.21k| const char* d2 = digits2(dec_exp); 1087| 1.21k| *buffer = d2[0]; 1088| 1.21k| buffer += hundreds_written | unsigned(dec_exp >= 10); 1089| 1.21k| *buffer = d2[1]; 1090| 1.21k| return buffer + 1; 1091| 2.05k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7to_bitsEd: 358| 2.77k| { 359| 2.77k| sig_type bits; 360| 2.77k| memcpy(&bits, &value, sizeof(value)); 361| 2.77k| return bits; 362| 2.77k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_expEm: 367| 2.77k| { 368| 2.77k| return static_cast((bits << 1) >> (num_sig_bits + 1)); 369| 2.77k| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_sigEm: 365| 2.77k| static auto get_sig(sig_type bits) noexcept -> sig_type { return bits & (implicit_bit - 1); } _ZN3glz4zmij11detail_impl12float_traitsIdE11is_negativeEm: 364| 2.77k| 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.05k| { 869| 2.05k| using traits = float_traits; 870| 2.05k| int64_t bin_exp = raw_exp - traits::exp_offset; 871| 2.05k| constexpr int num_bits = std::numeric_limits::digits; 872| | 873| 2.05k| constexpr uint64_t log10_2_sig = 78'913; 874| 2.05k| constexpr int32_t log10_2_exp = 18; 875| 2.05k| 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.05k| else { 881| 2.05k| dec_exp = compute_dec_exp(bin_exp); 882| 2.05k| } 883| 2.05k| uint64_t even = 1 - (bin_sig & 1); 884| 2.05k| constexpr int32_t extra_shift = exp_shift_table::extra_shift; 885| | 886| 2.05k| if (!regular) [[unlikely]] { ------------------ | Branch (886:14): [True: 307, False: 1.74k] ------------------ 887| 307| int32_t irregular_dec_exp = compute_dec_exp(bin_exp, false); 888| 307| int32_t shift = compute_exp_shift(bin_exp, irregular_dec_exp + 1) + extra_shift; 889| 307| uint128 pow10 = c.pow10_significands[-irregular_dec_exp - 1]; 890| 307| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 891| | 892| 307| int64_t integral = p.hi >> extra_shift; 893| 307| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 894| | 895| 307| uint64_t half_ulp = pow10.hi >> (extra_shift + 1 - shift); 896| 307| bool round_up = half_ulp > ~uint64_t(0) - fractional; 897| 307| bool round_down = (half_ulp >> 1) > fractional; 898| 307| integral += round_up; 899| | 900| 307| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, (uint64_t(1) << 63) - 1)); 901| 307| int32_t lo = static_cast(umul128_add_hi64(fractional - (half_ulp >> 1), 10, ~uint64_t(0))); 902| 307| if (digit < lo) digit = lo; ------------------ | Branch (902:17): [True: 276, False: 31] ------------------ 903| 307| return {integral, irregular_dec_exp, digit, (round_up + round_down) == 0}; 904| 307| } 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.74k| else { 928| 1.74k| int32_t shift = exp_shift_table::enable ? exp_shifts_v.data[bin_exp + traits::exp_offset] ------------------ | Branch (928:29): [True: 1.74k, Folded] ------------------ 929| 1.74k| : compute_exp_shift(bin_exp, dec_exp + 1) + extra_shift; 930| 1.74k| ZMIJ_ASM(("" : "+r"(dec_exp))); ------------------ | | 126| 1.74k|#define ZMIJ_ASM(x) asm x ------------------ 931| 1.74k| uint128 pow10 = c.pow10_significands[-dec_exp - 1]; 932| 1.74k| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 933| 1.74k| int64_t integral = p.hi >> extra_shift; 934| 1.74k| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 935| 1.74k| uint64_t half_ulp = (pow10.hi >> (extra_shift + 1 - shift)) + even; 936| 1.74k| bool round_up = fractional + half_ulp < fractional; 937| 1.74k| bool round_down = half_ulp > fractional; 938| 1.74k| integral += round_up; 939| | 940| 1.74k| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, c.biased_half)); 941| 1.74k| if (fractional == (1ull << 62)) [[unlikely]] { ------------------ | Branch (941:17): [True: 3, False: 1.74k] ------------------ 942| 3| digit = 2; 943| 3| } 944| 1.74k| return {integral, dec_exp, digit, (round_up + round_down) == 0}; 945| 1.74k| } 946| 1.74k| } _ZN3glz4zmij11detail_impl15compute_dec_expElb: 333| 2.35k| { 334| 2.35k| assert(bin_exp >= -1334 && bin_exp <= 2620); ------------------ | Branch (334:10): [True: 2.35k, False: 0] | Branch (334:10): [True: 2.35k, False: 0] | Branch (334:10): [True: 2.35k, False: 0] ------------------ 335| 2.35k| constexpr int log10_3_over_4_sig = 131'072; 336| 2.35k| constexpr int log10_2_sig = 315'653, log10_2_exp = 20; 337| 2.35k| return static_cast((bin_exp * log10_2_sig - !regular * log10_3_over_4_sig) >> log10_2_exp); 338| 2.35k| } _ZN3glz4zmij11detail_impl17compute_exp_shiftEli: 457| 307| { 458| 307| assert(dec_exp >= -350 && dec_exp <= 350); ------------------ | Branch (458:10): [True: 307, False: 0] | Branch (458:10): [True: 307, False: 0] | Branch (458:10): [True: 307, False: 0] ------------------ 459| 307| constexpr int log2_pow10_sig = 217'707, log2_pow10_exp = 16; 460| 307| int pow10_bin_exp = -dec_exp * log2_pow10_sig >> log2_pow10_exp; 461| 307| return static_cast(bin_exp + pow10_bin_exp + 1); 462| 307| } _ZNK3glz4zmij11detail_impl23pow10_significand_tableILb0EEixEi: 440| 2.05k| { 441| 2.05k| constexpr int dec_exp_min = -293; 442| 2.05k| int i = dec_exp - dec_exp_min; 443| 2.05k| if (compress) return compute(i); ------------------ | Branch (443:17): [Folded, False: 2.05k] ------------------ 444| 2.05k| if (!split_tables) return {data[i * 2], data[i * 2 + 1]}; ------------------ | Branch (444:17): [True: 2.05k, 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.05k| } _ZN3glz4zmij11detail_impl13umul192_hi128Emmm: 308| 2.05k| { 309| 2.05k| uint128_t p = umul128(x_hi, y); 310| 2.05k| uint64_t lo = uint64_t(p) + uint64_t(umul128(x_lo, y) >> 64); 311| 2.05k| return {uint64_t(p >> 64) + (lo < uint64_t(p)), lo}; 312| 2.05k| } _ZN3glz4zmij11detail_impl7umul128Emm: 265| 4.53k| { 266| 4.53k|#if ZMIJ_USE_INT128 267| 4.53k| 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.53k| } _ZN3glz4zmij11detail_impl16umul128_add_hi64Emmm: 298| 2.35k| { 299| 2.35k|#if ZMIJ_USE_INT128 300| 2.35k| 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.35k| } _ZN3glz4zmij11detail_impl5div10Em: 326| 428| { 327| 428| assert(x <= (1ull << 62)); ------------------ | Branch (327:10): [True: 428, False: 0] ------------------ 328| 428| constexpr uint64_t div10_sig64 = (1ull << 63) / 5 + 1; 329| 428| return ZMIJ_USE_INT128 ? umul128_hi64(x, div10_sig64) : x / 10; ------------------ | | 247| 428|#define ZMIJ_USE_INT128 1 | | ------------------ | | | Branch (247:25): [True: 428, Folded] | | ------------------ ------------------ 330| 428| } _ZN3glz4zmij11detail_impl12umul128_hi64Emm: 295| 428| 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.05k| { 810| | if constexpr (num_bits == 32) { 811| | auto result = to_bcd8(value); 812| | return {result.bcd + zeros_v, result.len}; 813| | } 814| 2.05k| 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.05k| uint32_t abbccddee = uint32_t(value / 100'000'000); 834| 2.05k| uint32_t ffgghhii = uint32_t(value % 100'000'000); 835| | 836| 2.05k| const __m128i zeros = _mm_load_si128(m128ptr(&c.zeros)); 837| 2.05k| 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.05k| auto bcd = _mm_shuffle_epi32(unshuffled_bcd, _MM_SHUFFLE(0, 1, 2, 3)); 843| 2.05k|#endif 844| | 845| 2.05k| __m128i mask128 = _mm_cmpgt_epi8(bcd, _mm_setzero_si128()); 846| 2.05k| 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.05k| int len = 63 - clz((mask << 1) | 1); 851| 2.05k|#endif 852| 2.05k| return {_mm_or_si128(bcd, zeros), len}; 853| 2.05k|#endif 854| 2.05k| } 855| 2.05k| } _ZN3glz4zmij11detail_impl20to_unshuffled_digitsILb0EEEDv2_xjjRKNS1_9constantsIXT_EEE: 735| 2.05k| { 736| 2.05k| const __m128i div10k = _mm_load_si128(m128ptr(&c.div10k)); 737| 2.05k| const __m128i neg10k = _mm_load_si128(m128ptr(&c.neg10k)); 738| 2.05k| __m128i x = _mm_set_epi64x(bbccddee, ffgghhii); 739| 2.05k| __m128i y = _mm_add_epi64(x, _mm_mul_epu32(neg10k, _mm_srli_epi64(_mm_mul_epu32(x, div10k), div10k_exp))); 740| 2.05k| return to_bcd_4x4(y, c); 741| 2.05k| } _ZN3glz4zmij11detail_impl10to_bcd_4x4ILb0EEEDv2_xS3_RKNS1_9constantsIXT_EEE: 712| 2.05k| { 713| 2.05k| const __m128i div100 = _mm_load_si128(m128ptr(&c.div100)); 714| 2.05k| 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.05k| const __m128i hundred = _mm_load_si128(m128ptr(&c.hundred)); 723| 2.05k| const __m128i moddiv10 = _mm_load_si128(m128ptr(&c.moddiv10)); 724| | 725| 2.05k| __m128i y_div_100 = _mm_srli_epi16(_mm_mulhi_epu16(y, div100), 3); 726| 2.05k| __m128i y_mod_100 = _mm_sub_epi16(y, _mm_mullo_epi16(y_div_100, hundred)); 727| 2.05k| __m128i z = _mm_or_si128(_mm_slli_epi32(y_mod_100, 16), y_div_100); 728| 2.05k| return _mm_sub_epi16(_mm_slli_epi16(z, 8), _mm_mullo_epi16(moddiv10, _mm_mulhi_epu16(z, div10))); 729| 2.05k|#endif 730| 2.05k| } _ZN3glz4zmij11detail_impl3clzEm: 187| 2.05k| { 188| 2.05k| assert(x != 0); ------------------ | Branch (188:10): [True: 2.05k, False: 0] ------------------ 189| 2.05k|#if ZMIJ_HAS_BUILTIN(__builtin_clzll) 190| 2.05k| 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.05k| } _ZNK3glz4zmij11detail_impl20dec_exp_format_table3getINS1_12float_traitsIdEEEERKNS2_5entryEi: 559| 837| { 560| 837| constexpr auto min = traits::min_fixed_dec_exp, max = Traits::max_fixed_dec_exp; 561| 837| unsigned i = unsigned(dec_exp - min); 562| 837| return data[i <= unsigned(max - min) ? i : num_entries - 1]; ------------------ | Branch (562:25): [True: 837, False: 0] ------------------ 563| 837| }