LLVMFuzzerTestOneInput: 181| 13.2k|{ 182| 13.2k| const std::string_view input{reinterpret_cast(Data), Size}; 183| | 184| | // Raw bytes: header validation, length arithmetic, and the query/body views it hands out. 185| 13.2k| { 186| 13.2k| const auto buf = exact_buffer(input); 187| 13.2k| drive({buf.data(), buf.size()}); 188| 13.2k| drive_plugin({buf.data(), buf.size()}); 189| 13.2k| } 190| | 191| 13.2k| if (Size < 2) { ------------------ | Branch (191:8): [True: 2, False: 13.2k] ------------------ 192| 2| return 0; 193| 2| } 194| | 195| | // Wrapped: the first byte picks the framing, the second says how much of the rest is the query. 196| | // The query is what the dispatch walks and the body is what the reader parses, so splitting the 197| | // input between them lets a single corpus entry drive both. 198| 13.2k| const uint8_t flags = Data[0]; 199| 13.2k| const std::string_view rest = input.substr(2); 200| 13.2k| const size_t query_size = rest.empty() ? 0 : size_t(Data[1]) % (rest.size() + 1); ------------------ | Branch (200:30): [True: 5, False: 13.2k] ------------------ 201| 13.2k| const std::string_view query = rest.substr(0, query_size); 202| 13.2k| const std::string_view body = rest.substr(query_size); 203| | 204| 13.2k| { 205| 13.2k| const auto framed = framed_message(query, body, flags); 206| 13.2k| const auto buf = exact_buffer(framed); 207| 13.2k| drive({buf.data(), buf.size()}); 208| 13.2k| } 209| | 210| | // The same body against a fixed query that is known to resolve, so the body reader is reached 211| | // even when the fuzzer has not yet learned what a valid JSON pointer looks like. 212| | // "" is the root endpoint, which reads the whole registered object in one document -- every 213| | // nested struct, container, optional and variant at once, and the deepest reader nesting on 214| | // offer. It is the widest single target here, so it must not be left out of the list. 215| 13.2k| for (std::string_view known : {"", "/value", "/name", "/position", "/position/x", "/inner", "/inner/label", ------------------ | Branch (215:32): [True: 278k, False: 13.2k] ------------------ 216| 13.2k| "/series", "/table", "/maybe", "/measure", "/doubled", "/greet", "/midpoint", 217| 278k| "/total", "/reset", "/counter", "/scale", "/bump", "/shift", "/tag"}) { 218| 278k| const auto framed = framed_message(known, body, flags); 219| 278k| const auto buf = exact_buffer(framed); 220| 278k| drive({buf.data(), buf.size()}); 221| 278k| } 222| | 223| 13.2k| return 0; 224| 13.2k|} repe_registry.cpp:_ZN12_GLOBAL__N_112exact_bufferENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE: 113| 493k| { 114| 493k| std::vector buf(bytes.size()); 115| 493k| if (!bytes.empty()) { ------------------ | Branch (115:11): [True: 493k, False: 0] ------------------ 116| 493k| std::memcpy(buf.data(), bytes.data(), bytes.size()); 117| 493k| } 118| 493k| return buf; 119| 493k| } repe_registry.cpp:_ZN12_GLOBAL__N_15driveENSt3__14spanIKcLm18446744073709551615EEE: 146| 304k| { 147| 304k| glz::registry<> registry; 148| 304k| fuzz_api api{}; 149| 304k| repe_fuzz::member_api members{}; 150| | // members first, so the last registration -- and therefore the root endpoint -- is the wider 151| | // of the two objects. Root reads the whole object in one document, so it should be the one 152| | // with the nested struct, containers, optional and variant in it. 153| 304k| registry.on(members); 154| 304k| registry.on(api); 155| | 156| 304k| std::string response; 157| 304k| registry.call(request, response); 158| 304k| if (!response.empty()) { ------------------ | Branch (158:11): [True: 188k, False: 116k] ------------------ 159| | // The response is a message in its own right, so parsing it back exercises the header 160| | // reader on bytes the registry itself produced. Copy it out at exactly its own size first: 161| | // a std::string keeps an implicit '\0' at data()[size()] and allocator slack behind it, 162| | // which is the very thing this target exists to not have. 163| 188k| const auto buf = exact_buffer(response); 164| 188k| [[maybe_unused]] auto parsed = glz::repe::parse_request({buf.data(), buf.size()}); 165| 188k| } 166| 304k| } _ZNK9repe_fuzz8fuzz_api7doubledMUliE_clEi: 67| 378| std::function doubled = [](int32_t v) { return int32_t(uint32_t(v) * 2u); }; _ZNK9repe_fuzz8fuzz_api5greetMUlRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE_clESA_: 68| 445| std::function greet = [](const std::string& who) { return "hi " + who; }; _ZNK9repe_fuzz8fuzz_api8midpointMUlRKNS_5pointEE_clES4_: 69| 78| std::function midpoint = [](const point& p) -> point { return {p.x / 2, p.y / 2}; }; _ZNK9repe_fuzz8fuzz_api5totalMUlRNSt3__16vectorIdNS2_9allocatorIdEEEEE_clES7_: 70| 408| std::function&)> total = [](std::vector& v) { 71| 408| double sum{}; 72| 1.70k| for (auto d : v) sum += d; ------------------ | Branch (72:22): [True: 1.70k, False: 408] ------------------ 73| 408| return sum; 74| 408| }; _ZNK9repe_fuzz8fuzz_api5resetMUlvE_clEv: 75| 13.1k| std::function reset = [] {}; _ZN9repe_fuzz10member_api5scaleEi: 90| 452| { 91| 452| counter = int32_t(uint32_t(counter) + uint32_t(v)); 92| 452| return int32_t(uint32_t(v) * 3u); 93| 452| } _ZN9repe_fuzz10member_api4bumpEv: 94| 13.1k| void bump() { counter = int32_t(uint32_t(counter) + 1u); } _ZN9repe_fuzz10member_api5shiftERKNS_5pointE: 95| 155| point shift(const point& p) { return {p.x + 1, p.y + 1}; } _ZN9repe_fuzz10member_api3tagERKNS_6nestedE: 96| 297| std::string tag(const nested& n) { return n.label; } repe_registry.cpp:_ZN12_GLOBAL__N_112drive_pluginENSt3__14spanIKcLm18446744073709551615EEE: 172| 13.2k| { 173| 13.2k| glz::registry<> registry; 174| 13.2k| fuzz_api api{}; 175| 13.2k| registry.on(api); 176| 13.2k| [[maybe_unused]] auto out = glz::repe::plugin_call(registry, request.data(), request.size()); 177| 13.2k| } repe_registry.cpp:_ZN12_GLOBAL__N_114framed_messageENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEES4_h: 122| 291k| { 123| 291k| glz::repe::header hdr{}; 124| 291k| hdr.spec = glz::repe::repe_magic; 125| 291k| hdr.version = 1; 126| 291k| hdr.id = 1; 127| 291k| hdr.notify = (flags & 0x1) ? 1 : 0; ------------------ | Branch (127:20): [True: 115k, False: 175k] ------------------ 128| 291k| hdr.query_length = query.size(); 129| 291k| hdr.body_length = body.size(); 130| 291k| hdr.length = sizeof(glz::repe::header) + query.size() + body.size(); 131| 291k| hdr.query_format = glz::repe::query_format::JSON_POINTER; 132| 291k| hdr.body_format = glz::repe::body_format::JSON; 133| | // The registry echoes a request that already carries an error back to the sender without 134| | // dispatching it. Nothing else in this target sets ec, so without this that branch is dead. 135| 291k| hdr.ec = (flags & 0x2) ? glz::error_code::invalid_query : glz::error_code::none; ------------------ | Branch (135:16): [True: 2.99k, False: 288k] ------------------ 136| | 137| 291k| std::string msg; 138| 291k| msg.resize(hdr.length); 139| 291k| std::memcpy(msg.data(), &hdr, sizeof(hdr)); 140| 291k| std::memcpy(msg.data() + sizeof(hdr), query.data(), query.size()); 141| 291k| std::memcpy(msg.data() + sizeof(hdr) + query.size(), body.data(), body.size()); 142| 291k| return msg; 143| 291k| } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__16vectorIiNS1_9allocatorIiEEEEEEbOT_: 284| 91| { 285| 91|#ifdef __cpp_lib_ranges 286| 91| return std::ranges::empty(rng); 287| |#else 288| | // in lieu of std::ranges::empty 289| | if constexpr (requires() { 290| | { rng.empty() } -> std::convertible_to; 291| | }) { 292| | return rng.empty(); 293| | } 294| | else if constexpr (requires() { 295| | { rng.size() } -> std::same_as; 296| | }) { 297| | return rng.size() == std::size_t{0}; 298| | } 299| | else { 300| | return std::cbegin(rng) == std::cend(rng); 301| | } 302| |#endif 303| 91| } _ZN3glz11empty_rangeITkNS_5rangeERNSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEEEbOT_: 284| 91| { 285| 91|#ifdef __cpp_lib_ranges 286| 91| return std::ranges::empty(rng); 287| |#else 288| | // in lieu of std::ranges::empty 289| | if constexpr (requires() { 290| | { rng.empty() } -> std::convertible_to; 291| | }) { 292| | return rng.empty(); 293| | } 294| | else if constexpr (requires() { 295| | { rng.size() } -> std::same_as; 296| | }) { 297| | return rng.size() == std::size_t{0}; 298| | } 299| | else { 300| | return std::cbegin(rng) == std::cend(rng); 301| | } 302| |#endif 303| 91| } _ZN3glz12ensure_spaceINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10is_contextENS_7contextEEEbRT0_RT_m: 181| 23.4k| { 182| 23.4k| using Buffer = std::remove_cvref_t; 183| | 184| 23.4k| if constexpr (vector_like) { 185| 23.4k| if (required > b.size()) [[unlikely]] { ------------------ | Branch (185:14): [True: 230, False: 23.1k] ------------------ 186| | // 2× growth amortizes repeated reallocations to O(n) total cost. 187| 230| b.resize(2 * required); 188| 230| } 189| 23.4k| return true; 190| | } 191| | else if constexpr (has_bounded_capacity) { 192| | if (required > buffer_traits::capacity(b)) [[unlikely]] { 193| | ctx.error = error_code::buffer_overflow; 194| | return false; 195| | } 196| | return true; 197| | } 198| | else { 199| | return true; // Raw pointer or other - trust caller 200| | } 201| 23.4k| } _ZN3glz13buffer_traitsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE8finalizeERS7_m: 58| 22.0k| { 59| 22.0k| if constexpr (is_resizable) { 60| 22.0k| b.resize(written); 61| 22.0k| } 62| | // For fixed buffers: no-op, count is returned in result 63| 22.0k| } _ZN3glz10get_memberIRN9repe_fuzz10member_apiERKMS2_iEEDcOT_OT0_: 616| 304k| { 617| 304k| using V = std::decay_t; 618| 304k| if constexpr (std::is_member_object_pointer_v) { 619| 304k| return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 304k| } _ZN3glz10get_memberIRN9repe_fuzz10member_apiERKMS2_FiiEEEDcOT_OT0_: 616| 304k| { 617| 304k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 304k| else if constexpr (std::is_member_function_pointer_v) { 622| 304k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 304k| } _ZN3glz10get_memberIRN9repe_fuzz10member_apiERKMS2_FvvEEEDcOT_OT0_: 616| 304k| { 617| 304k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 304k| else if constexpr (std::is_member_function_pointer_v) { 622| 304k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 304k| } _ZN3glz10get_memberIRN9repe_fuzz10member_apiERKMS2_FNS1_5pointERKS4_EEEDcOT_OT0_: 616| 304k| { 617| 304k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 304k| else if constexpr (std::is_member_function_pointer_v) { 622| 304k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 304k| } _ZN3glz10get_memberIRN9repe_fuzz5pointERdEEDcOT_OT0_: 616| 680k| { 617| 680k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 680k| else { 639| 680k| return element; 640| 680k| } 641| 680k| } _ZN3glz10get_memberIRN9repe_fuzz10member_apiERKMS2_FNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS1_6nestedEEEEDcOT_OT0_: 616| 304k| { 617| 304k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| 304k| else if constexpr (std::is_member_function_pointer_v) { 622| 304k| return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| | else { 639| | return element; 640| | } 641| 304k| } _ZN3glz10get_memberIRN9repe_fuzz6nestedERiEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz6nestedERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 616| 326k| { 617| 326k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 326k| else { 639| 326k| return element; 640| 326k| } 641| 326k| } _ZN3glz8str_viewINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_EENS1_17basic_string_viewIcS4_EEOT0_: 288| 843| { 289| | if constexpr (std::same_as, std::string_view>) { 290| | return value; // already the answer; rebuilding it from data() and size() costs instructions 291| | } 292| | else if constexpr (!char_array_t && std::is_pointer_v>) { 293| | return value ? std::string_view{value} : std::string_view{}; 294| | } 295| 843| else if constexpr (has_data && has_size) { 296| 843| return std::string_view{value.data(), value.size()}; 297| | } 298| | else { 299| | return std::string_view{value}; 300| | } 301| 843| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERiEEDcOT_OT0_: 616| 356k| { 617| 356k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 356k| else { 639| 356k| return element; 640| 356k| } 641| 356k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNS1_5pointEEEDcOT_OT0_: 616| 319k| { 617| 319k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 319k| else { 639| 319k| return element; 640| 319k| } 641| 319k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNS1_6nestedEEEDcOT_OT0_: 616| 319k| { 617| 319k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 319k| else { 639| 319k| return element; 640| 319k| } 641| 319k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__16vectorIiNS4_9allocatorIiEEEEEEDcOT_OT0_: 616| 327k| { 617| 327k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 327k| else { 639| 327k| return element; 640| 327k| } 641| 327k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEEEEDcOT_OT0_: 616| 319k| { 617| 319k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 319k| else { 639| 319k| return element; 640| 319k| } 641| 319k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18optionalIdEEEEDcOT_OT0_: 616| 320k| { 617| 320k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 320k| else { 639| 320k| return element; 640| 320k| } 641| 320k| } _ZN3glz10get_memberIRN9repe_fuzz6amountERdEEDcOT_OT0_: 616| 19.5k| { 617| 19.5k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 19.5k| else { 639| 19.5k| return element; 640| 19.5k| } 641| 19.5k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_6amountEEEEEEDcOT_OT0_: 616| 327k| { 617| 327k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 327k| else { 639| 327k| return element; 640| 327k| } 641| 327k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18functionIFiiEEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18functionIFNS1_5pointERKS6_EEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz10get_memberIRN9repe_fuzz8fuzz_apiERNSt3__18functionIFvvEEEEEDcOT_OT0_: 616| 318k| { 617| 318k| using V = std::decay_t; 618| | if constexpr (std::is_member_object_pointer_v) { 619| | return value.*element; 620| | } 621| | else if constexpr (std::is_member_function_pointer_v) { 622| | return element; 623| | } 624| | else if constexpr (std::invocable && not eigen_t) { 625| | // Eigen places a static_assert inside of the operator()(), so we must target 626| | // matrix types and reject them from the invocable check 627| | // Eigen ought to put the check in the `enable_if` for operator()() 628| | return std::invoke(std::forward(element), std::forward(value)); 629| | } 630| | else if constexpr (std::is_pointer_v && !std::is_reference_v) { 631| | if constexpr (std::invocable) { 632| | return std::invoke(*element, std::forward(value)); 633| | } 634| | else { 635| | return *element; 636| | } 637| | } 638| 318k| else { 639| 318k| return element; 640| 318k| } 641| 318k| } _ZN3glz11enter_depthITkNS_10is_contextENS_7contextEEEbRT_: 250| 91.5k| { 251| 91.5k| if (ctx.depth >= max_recursive_depth_limit) [[unlikely]] { ------------------ | Branch (251:11): [True: 0, False: 91.5k] ------------------ 252| 0| ctx.error = error_code::exceeded_max_recursive_depth; 253| 0| return true; 254| 0| } 255| 91.5k| ++ctx.depth; 256| 91.5k| return false; 257| 91.5k| } _ZNK3glz9error_ctxcvbEv: 129| 22.0k| operator bool() const noexcept { return ec != error_code::none; } _ZN3glz18charge_speculationITkNS_10is_contextENS_7contextEEEbRT_m: 218| 659| { 219| 659| if constexpr (requires { ctx.speculation_budget; }) { 220| 659| if (ctx.speculation_budget == 0) { ------------------ | Branch (220:14): [True: 659, False: 0] ------------------ 221| 659| return true; 222| 659| } 223| 0| ctx.speculation_budget = consumed >= ctx.speculation_budget ? 1 : ctx.speculation_budget - consumed; ------------------ | Branch (223:35): [True: 0, False: 0] ------------------ 224| 0| return ctx.speculation_budget > 1; 225| | } 226| | else { 227| | return true; 228| | } 229| 659| } _ZN3glz21speculation_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 235| 66| { 236| 66| if constexpr (requires { ctx.speculation_budget; }) { 237| 66| return ctx.speculation_budget == 1; // the latched floor; 0 means unbudgeted 238| | } 239| | else { 240| | return false; 241| | } 242| 66| } _ZN3glz23finalize_top_level_readITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_PKcS7_S7_: 115| 257k| { 116| 257k| if constexpr (Opts.format == JSON && !check_null_terminated(Opts)) { 117| | // Deliberately not [[unlikely]]: a body that ends with the buffer lands here on every 118| | // successful read, which is the ordinary case for a registry parsing a wire span. 119| | // start < it, not !=, because a streaming origin can be empty or overshoot on an error 120| | // path; neither is an absent value. 121| 257k| if (ctx.error == error_code::end_reached && ctx.depth == 0 && it == end && start < it) { ------------------ | Branch (121:14): [True: 8.07k, False: 249k] | Branch (121:54): [True: 3.42k, False: 4.64k] | Branch (121:72): [True: 3.42k, False: 0] | Branch (121:85): [True: 3.42k, False: 0] ------------------ 122| 3.42k| context ws_ctx{}; // only written to when skip_ws parses a comment; the result is unused 123| 3.42k| const char* consumed = start; 124| 3.42k| skip_ws(ws_ctx, consumed, it); 125| 3.42k| if (consumed == it) { ------------------ | Branch (125:17): [True: 640, False: 2.78k] ------------------ 126| 640| ctx.error = error_code::no_read_input; 127| 640| } 128| 3.42k| } 129| 257k| } 130| 257k| finalize_read_context(ctx); 131| 257k| } _ZN3glz21finalize_read_contextITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEEEvOT0_: 76| 257k| { 77| | // A partial read stops as soon as it has the fields it was asked for, so it unwinds through 78| | // its enclosing containers on an error code rather than through their closing braces, and 79| | // none of them decrement depth on the way out. Depth is left standing at whatever nesting the 80| | // last field sat at. 81| | // 82| | // That has to be cleared here rather than left for the next read to trip over. This is the 83| | // one path that reports success with depth still raised, and depth is what settle_end_reached 84| | // reads to tell a completed parse from a truncated one -- so a context reused after a partial 85| | // read would see a later well-formed buffer settle to unexpected_end. Reads that end any 86| | // other way either return depth to zero themselves or carry an error, and a context holding 87| | // an error short-circuits the next read before it parses anything. 88| | if constexpr (check_partial_read(Opts)) { 89| | if (ctx.error == error_code::partial_read_complete) [[likely]] { 90| | ctx.error = error_code::none; 91| | ctx.depth = 0; 92| | return; 93| | } 94| | } 95| 257k| settle_end_reached(ctx); 96| 257k| } _ZN3glz18settle_end_reachedITkNS_10is_contextERNS_7contextEEEvOT_: 68| 257k| { 69| 257k| if (ctx.error == error_code::end_reached) { ------------------ | Branch (69:11): [True: 7.43k, False: 250k] ------------------ 70| 7.43k| ctx.error = (ctx.depth == 0) ? error_code::none : error_code::unexpected_end; ------------------ | Branch (70:22): [True: 2.78k, False: 4.64k] ------------------ 71| 7.43k| } 72| 257k| } _ZN3glz12format_errorINSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEENS1_12basic_stringIcS4_NS1_9allocatorIcEEEERKNS_9error_ctxERKT_: 3311| 151k| { 3312| 151k| const auto error_type_str = meta::keys[uint32_t(pe.ec)]; 3313| | 3314| 151k| const auto info = detail::get_source_info(buffer, pe.count); 3315| 151k| auto error_str = detail::generate_error_string(error_type_str, info); 3316| 151k| if (pe.custom_error_message.size()) { ------------------ | Branch (3316:11): [True: 0, False: 151k] ------------------ 3317| 0| error_str.append(" "); 3318| 0| error_str.append(pe.custom_error_message.begin(), pe.custom_error_message.end()); 3319| 0| } 3320| 151k| return error_str; 3321| 151k| } _ZN3glz11decode_hashILj10EN9repe_fuzz5pointEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm1ELm1EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2465| 64.7k| { 2466| | if constexpr (HashInfo.sized_hash) { 2467| | const auto* c = quote_memchr(it, end); 2468| | if (c) [[likely]] { 2469| | const auto n = size_t(static_cast>(c) - it); 2470| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2471| | return N; // error 2472| | } 2473| | 2474| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2475| | return HashInfo.table[h % bsize]; 2476| | } 2477| | else [[unlikely]] { 2478| | return N; 2479| | } 2480| | } 2481| 64.7k| else { 2482| 64.7k| if constexpr (N == 2) { 2483| | if constexpr (uindex > 0) { 2484| | if ((it + uindex) >= end) [[unlikely]] { 2485| | return N; // error 2486| | } 2487| | } 2488| | // Avoids using a hash table 2489| 64.7k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2490| 64.7k| return size_t(bool(it[uindex] ^ first_key_char)); 2491| | } 2492| | else { 2493| | if constexpr (uindex > 0) { 2494| | if ((it + uindex) >= end) [[unlikely]] { 2495| | return N; // error 2496| | } 2497| | } 2498| | return HashInfo.table[uint8_t(it[uindex])]; 2499| | } 2500| 64.7k| } 2501| 64.7k| } _ZN3glz11decode_hashILj10EN9repe_fuzz6nestedEXtlNS_11hash_info_tIS2_Lm256EEELNS_9hash_typeE1EtlNSt3__15arrayIhLm256EEEtlA256_hLh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh0ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh1ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2ELh2EEELm5ELm5EEELS5_1EE2opIRPKcSD_EEmOT_T0_: 2465| 22.1k| { 2466| | if constexpr (HashInfo.sized_hash) { 2467| | const auto* c = quote_memchr(it, end); 2468| | if (c) [[likely]] { 2469| | const auto n = size_t(static_cast>(c) - it); 2470| | if (n == 0 || n > HashInfo.max_length || HashInfo.unique_index >= size_t(end - it)) [[unlikely]] { 2471| | return N; // error 2472| | } 2473| | 2474| | const auto h = bitmix(uint16_t(it[HashInfo.unique_index]) | (uint16_t(n) << 8), HashInfo.seed); 2475| | return HashInfo.table[h % bsize]; 2476| | } 2477| | else [[unlikely]] { 2478| | return N; 2479| | } 2480| | } 2481| 22.1k| else { 2482| 22.1k| if constexpr (N == 2) { 2483| | if constexpr (uindex > 0) { 2484| | if ((it + uindex) >= end) [[unlikely]] { 2485| | return N; // error 2486| | } 2487| | } 2488| | // Avoids using a hash table 2489| 22.1k| constexpr auto first_key_char = reflect::keys[0][uindex]; 2490| 22.1k| return size_t(bool(it[uindex] ^ first_key_char)); 2491| | } 2492| | else { 2493| | if constexpr (uindex > 0) { 2494| | if ((it + uindex) >= end) [[unlikely]] { 2495| | return N; // error 2496| | } 2497| | } 2498| | return HashInfo.table[uint8_t(it[uindex])]; 2499| | } 2500| 22.1k| } 2501| 22.1k| } _ZN3glz11decode_hashILj10EN9repe_fuzz8fuzz_apiEXtlNS_11hash_info_tIS2_Lm128EEELNS_9hash_typeE2EtlNSt3__15arrayIhLm128EEEtlA128_hLh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh11ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh6ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh9ELh13ELh13ELh13ELh13ELh13ELh12ELh13ELh13ELh13ELh13ELh0ELh13ELh13ELh13ELh13ELh13ELh13ELh5ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh4ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh1ELh13ELh10ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh2ELh3ELh13ELh13ELh13ELh13ELh13ELh13ELh8ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh13ELh7ELh13ELh13ELh13ELh13ELh13ELh13ELh13EEELm4ELm8ELm15149911783463666029ELm18446744073709551615ELb0ELm2EEELS5_2EE2opIRPKcSD_EEmOT_T0_: 2530| 68.4k| { 2531| 68.4k| if constexpr (HashInfo.front_hash_bytes == 2) { 2532| 68.4k| if ((it + 2) >= end) [[unlikely]] { ------------------ | Branch (2532:17): [True: 107, False: 68.3k] ------------------ 2533| 107| return N; // error 2534| 107| } 2535| 68.3k| uint16_t h; 2536| | if consteval { 2537| | h = 0; 2538| | for (size_t i = 0; i < 2; ++i) { 2539| | h |= static_cast(static_cast(it[i])) << (8 * i); 2540| | } 2541| | } 2542| 68.3k| else { 2543| 68.3k| std::memcpy(&h, it, 2); 2544| | if constexpr (std::endian::native == std::endian::big) { 2545| | h = std::byteswap(h); 2546| | } 2547| 68.3k| } 2548| 68.3k| return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2549| | } 2550| | else if constexpr (HashInfo.front_hash_bytes == 4) { 2551| | if ((it + 4) >= end) [[unlikely]] { 2552| | return N; 2553| | } 2554| | uint32_t h; 2555| | if consteval { 2556| | h = 0; 2557| | for (size_t i = 0; i < 4; ++i) { 2558| | h |= static_cast(static_cast(it[i])) << (8 * i); 2559| | } 2560| | } 2561| | else { 2562| | std::memcpy(&h, it, 4); 2563| | if constexpr (std::endian::native == std::endian::big) { 2564| | h = std::byteswap(h); 2565| | } 2566| | } 2567| | return HashInfo.table[bitmix(h, HashInfo.seed) % bsize]; 2568| | } 2569| | else if constexpr (HashInfo.front_hash_bytes == 8) { 2570| | if ((it + 8) >= end) [[unlikely]] { 2571| | return N; 2572| | } 2573| | uint64_t h; 2574| | if consteval { 2575| | h = 0; 2576| | for (size_t i = 0; i < 8; ++i) { 2577| | h |= static_cast(static_cast(it[i])) << (8 * i); 2578| | } 2579| | } 2580| | else { 2581| | std::memcpy(&h, it, 8); 2582| | if constexpr (std::endian::native == std::endian::big) { 2583| | h = std::byteswap(h); 2584| | } 2585| | } 2586| | return HashInfo.table[rich_bitmix(h, HashInfo.seed) % bsize]; 2587| | } 2588| | else { 2589| | static_assert(false_v, "invalid hash algorithm"); 2590| | } 2591| 68.4k| } _ZN3glz6bitmixEmm: 1493| 68.3k| { 1494| 68.3k| h *= seed; 1495| 68.3k| return h ^ std::rotr(h, 49); 1496| 68.3k| }; _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEDnTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_: 78| 19.7k| { 79| 19.7k| context ctx{}; 80| 19.7k| return write(std::forward(value), buffer, ctx); 81| 19.7k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEDnTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 19.7k| { 19| 19.7k| using traits = buffer_traits>; 20| | 21| 19.7k| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 19.7k| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 19.7k, False: 0] ------------------ 24| 19.7k| buffer.resize(2 * write_padding_bytes); 25| 19.7k| } 26| 19.7k| } 27| 19.7k| size_t ix = 0; // overwrite index 28| 19.7k| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 19.7k| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 19.7k] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 19.7k| traits::finalize(buffer, ix); 35| 19.7k| return {ix, error_code::none, ctx.custom_error_message}; 36| 19.7k| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 400| { 79| 400| context ctx{}; 80| 400| return write(std::forward(value), buffer, ctx); 81| 400| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 400| { 19| 400| using traits = buffer_traits>; 20| | 21| 400| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 400| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 400, False: 0] ------------------ 24| 400| buffer.resize(2 * write_padding_bytes); 25| 400| } 26| 400| } 27| 400| size_t ix = 0; // overwrite index 28| 400| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 400| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 400] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 400| traits::finalize(buffer, ix); 35| 400| return {ix, error_code::none, ctx.custom_error_message}; 36| 400| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_: 78| 353| { 79| 353| context ctx{}; 80| 353| return write(std::forward(value), buffer, ctx); 81| 353| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiTkNS_13output_bufferENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 353| { 19| 353| using traits = buffer_traits>; 20| | 21| 353| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 353| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 353, False: 0] ------------------ 24| 353| buffer.resize(2 * write_padding_bytes); 25| 353| } 26| 353| } 27| 353| size_t ix = 0; // overwrite index 28| 353| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 353| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 353] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 353| traits::finalize(buffer, ix); 35| 353| return {ix, error_code::none, ctx.custom_error_message}; 36| 353| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_: 78| 112| { 79| 112| context ctx{}; 80| 112| return write(std::forward(value), buffer, ctx); 81| 112| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_OT2_: 18| 112| { 19| 112| using traits = buffer_traits>; 20| | 21| 112| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 112| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 112, False: 0] ------------------ 24| 112| buffer.resize(2 * write_padding_bytes); 25| 112| } 26| 112| } 27| 112| size_t ix = 0; // overwrite index 28| 112| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 112| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 112] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 112| traits::finalize(buffer, ix); 35| 112| return {ix, error_code::none, ctx.custom_error_message}; 36| 112| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOS9_RT1_: 78| 247| { 79| 247| context ctx{}; 80| 247| return write(std::forward(value), buffer, ctx); 81| 247| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSB_RT1_OT2_: 18| 247| { 19| 247| using traits = buffer_traits>; 20| | 21| 247| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 247| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 247, False: 0] ------------------ 24| 247| buffer.resize(2 * write_padding_bytes); 25| 247| } 26| 247| } 27| 247| size_t ix = 0; // overwrite index 28| 247| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 247| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 247] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 247| traits::finalize(buffer, ix); 35| 247| return {ix, error_code::none, ctx.custom_error_message}; 36| 247| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 47| { 79| 47| context ctx{}; 80| 47| return write(std::forward(value), buffer, ctx); 81| 47| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 47| { 19| 47| using traits = buffer_traits>; 20| | 21| 47| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 47| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 47, False: 0] ------------------ 24| 47| buffer.resize(2 * write_padding_bytes); 25| 47| } 26| 47| } 27| 47| size_t ix = 0; // overwrite index 28| 47| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 47| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 47] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 47| traits::finalize(buffer, ix); 35| 47| return {ix, error_code::none, ctx.custom_error_message}; 36| 47| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 367| { 79| 367| context ctx{}; 80| 367| return write(std::forward(value), buffer, ctx); 81| 367| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_13output_bufferES8_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 367| { 19| 367| using traits = buffer_traits>; 20| | 21| 367| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 367| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 367, False: 0] ------------------ 24| 367| buffer.resize(2 * write_padding_bytes); 25| 367| } 26| 367| } 27| 367| size_t ix = 0; // overwrite index 28| 367| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 367| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 367] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 367| traits::finalize(buffer, ix); 35| 367| return {ix, error_code::none, ctx.custom_error_message}; 36| 367| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSA_RT1_: 78| 444| { 79| 444| context ctx{}; 80| 444| return write(std::forward(value), buffer, ctx); 81| 444| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_13output_bufferENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_OT2_: 18| 444| { 19| 444| using traits = buffer_traits>; 20| | 21| 444| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 444| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 444, False: 0] ------------------ 24| 444| buffer.resize(2 * write_padding_bytes); 25| 444| } 26| 444| } 27| 444| size_t ix = 0; // overwrite index 28| 444| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 444| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 444] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 444| traits::finalize(buffer, ix); 35| 444| return {ix, error_code::none, ctx.custom_error_message}; 36| 444| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 113| { 79| 113| context ctx{}; 80| 113| return write(std::forward(value), buffer, ctx); 81| 113| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 113| { 19| 113| using traits = buffer_traits>; 20| | 21| 113| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 113| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 113, False: 0] ------------------ 24| 113| buffer.resize(2 * write_padding_bytes); 25| 113| } 26| 113| } 27| 113| size_t ix = 0; // overwrite index 28| 113| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 113| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 113] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 113| traits::finalize(buffer, ix); 35| 113| return {ix, error_code::none, ctx.custom_error_message}; 36| 113| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 44| { 79| 44| context ctx{}; 80| 44| return write(std::forward(value), buffer, ctx); 81| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedETkNS_13output_bufferENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 44| { 19| 44| using traits = buffer_traits>; 20| | 21| 44| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44, False: 0] ------------------ 24| 44| buffer.resize(2 * write_padding_bytes); 25| 44| } 26| 44| } 27| 44| size_t ix = 0; // overwrite index 28| 44| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44| traits::finalize(buffer, ix); 35| 44| return {ix, error_code::none, ctx.custom_error_message}; 36| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSD_RT1_: 78| 44| { 79| 44| context ctx{}; 80| 44| return write(std::forward(value), buffer, ctx); 81| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS2_9allocatorIiEEEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS4_IcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSF_RT1_OT2_: 18| 44| { 19| 44| using traits = buffer_traits>; 20| | 21| 44| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44, False: 0] ------------------ 24| 44| buffer.resize(2 * write_padding_bytes); 25| 44| } 26| 44| } 27| 44| size_t ix = 0; // overwrite index 28| 44| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44| traits::finalize(buffer, ix); 35| 44| return {ix, error_code::none, ctx.custom_error_message}; 36| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSI_RT1_: 78| 44| { 79| 44| context ctx{}; 80| 44| return write(std::forward(value), buffer, ctx); 81| 44| } _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| 44| { 19| 44| using traits = buffer_traits>; 20| | 21| 44| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44, False: 0] ------------------ 24| 44| buffer.resize(2 * write_padding_bytes); 25| 44| } 26| 44| } 27| 44| size_t ix = 0; // overwrite index 28| 44| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44| traits::finalize(buffer, ix); 35| 44| return {ix, error_code::none, ctx.custom_error_message}; 36| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSC_RT1_: 78| 44| { 79| 44| context ctx{}; 80| 44| return write(std::forward(value), buffer, ctx); 81| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_13output_bufferENS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEETkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_OT2_: 18| 44| { 19| 44| using traits = buffer_traits>; 20| | 21| 44| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44, False: 0] ------------------ 24| 44| buffer.resize(2 * write_padding_bytes); 25| 44| } 26| 44| } 27| 44| size_t ix = 0; // overwrite index 28| 44| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44| traits::finalize(buffer, ix); 35| 44| return {ix, error_code::none, ctx.custom_error_message}; 36| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9repe_fuzz6amountEEEETkNS_13output_bufferES9_Q15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSE_RT1_: 78| 44| { 79| 44| context ctx{}; 80| 44| return write(std::forward(value), buffer, ctx); 81| 44| } _ZN3glz5writeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9repe_fuzz6amountEEEETkNS_13output_bufferES9_TkNS_10is_contextERNS_7contextEQ15write_supportedIT0_XdtT_6formatEEEENS_9error_ctxEOSG_RT1_OT2_: 18| 44| { 19| 44| using traits = buffer_traits>; 20| | 21| 44| if constexpr (traits::is_resizable) { 22| | // A buffer could be size 1, to ensure we have sufficient memory we can't just check `empty()` 23| 44| if (buffer.size() < 2 * write_padding_bytes) { ------------------ | Branch (23:14): [True: 44, False: 0] ------------------ 24| 44| buffer.resize(2 * write_padding_bytes); 25| 44| } 26| 44| } 27| 44| size_t ix = 0; // overwrite index 28| 44| to>::template op(std::forward(value), ctx, buffer, ix); 29| | 30| 44| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (30:11): [True: 0, False: 44] ------------------ 31| 0| return {ix, ctx.error, ctx.custom_error_message}; 32| 0| } 33| | 34| 44| traits::finalize(buffer, ix); 35| 44| return {ix, error_code::none, ctx.custom_error_message}; 36| 44| } _ZN3glz11write_chars2opITnDaXtlNS_9opts_sizeEtlNS_4optsELj10ELb1ELb0ELb1ELb1EEEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_5num_tERKmTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 297k| { 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| 297k| if constexpr (resizable && not check_write_unchecked(Opts)) { 214| 297k| if (const auto k = ix + 64; k > b.size()) { ------------------ | Branch (214:41): [True: 0, False: 297k] ------------------ 215| 0| b.resize(2 * k); 216| 0| } 217| 297k| } 218| | 219| 297k| 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| | b.resize(2 * (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| | b.resize(2 * (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| 297k| else if constexpr (is_any_of) { 347| 297k| const auto start = reinterpret_cast(&b[ix]); 348| 297k| if constexpr (is_size_optimized(Opts)) { 349| | // Size mode: use glz::to_chars (400B lookup tables) 350| 297k| const auto end = glz::to_chars(start, value); 351| 297k| 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| 297k| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 891| { 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| | b.resize(2 * k); 216| | } 217| | } 218| | 219| 891| 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| | b.resize(2 * (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| | b.resize(2 * (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| 891| else if constexpr (is_any_of) { 347| 891| 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| 891| else { 354| | // Normal mode: use to_chars_40kb (40KB digit_quads table) 355| 891| const auto end = glz::to_chars_40kb(start, value); 356| 891| ix += size_t(end - start); 357| 891| } 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| 891| } _ZN3glz11write_chars2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEETkNS_5num_tERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 205| 988| { 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| | b.resize(2 * k); 216| | } 217| | } 218| | 219| 988| using V = std::decay_t; 220| | 221| 988| if constexpr (std::floating_point) { 222| 988| using opts_type = std::decay_t; 223| 988| 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| | b.resize(2 * (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| | b.resize(2 * (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| 988| else if constexpr (is_any_of) { 319| 988| const auto start = reinterpret_cast(&b[ix]); 320| 988| const auto end = glz::to_chars(start, value); 321| 988| 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| 988| } _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 808| 533k| { 809| | if constexpr (check_quoted_num(Opts)) { 810| | if (skip_ws(ctx, it, end)) { 811| | return; 812| | } 813| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 814| | return; 815| | } 816| | } 817| | 818| | if constexpr (!check_ws_handled(Opts)) { 819| | if (skip_ws(ctx, it, end)) { 820| | return; 821| | } 822| | } 823| | 824| 533k| using V = std::decay_t; 825| 533k| if constexpr (int_t) { 826| 533k| static_assert(sizeof(*it) == sizeof(char)); 827| | 828| | if constexpr (Opts.null_terminated) { 829| | if (not glz::atoi(value, it)) [[unlikely]] { 830| | ctx.error = error_code::parse_number_failure; 831| | return; 832| | } 833| | } 834| 533k| else { 835| 533k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (835:20): [True: 9.42k, False: 524k] ------------------ 836| 9.42k| ctx.error = error_code::parse_number_failure; 837| 9.42k| return; 838| 9.42k| } 839| 533k| } 840| | } 841| | else { 842| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 843| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 844| | if constexpr (is_float128) { 845| | auto [ptr, ec] = std::from_chars(it, end, value); 846| | if (ec != std::errc()) { 847| | ctx.error = error_code::parse_number_failure; 848| | return; 849| | } 850| | it = ptr; 851| | } 852| | else 853| |#endif 854| | { 855| | if constexpr (std::is_volatile_v>) { 856| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 857| | // place 858| | V temp; 859| | if constexpr (is_size_optimized(Opts)) { 860| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 861| | if (ec != std::errc{}) [[unlikely]] { 862| | ctx.error = error_code::parse_number_failure; 863| | return; 864| | } 865| | it = ptr; 866| | } 867| | else { 868| | auto [ptr, ec] = glz::from_chars(it, end, temp); 869| | if (ec != std::errc()) [[unlikely]] { 870| | ctx.error = error_code::parse_number_failure; 871| | return; 872| | } 873| | it = ptr; 874| | } 875| | value = temp; 876| | } 877| | else { 878| | if constexpr (is_size_optimized(Opts)) { 879| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 880| | if (ec != std::errc{}) [[unlikely]] { 881| | ctx.error = error_code::parse_number_failure; 882| | return; 883| | } 884| | it = ptr; 885| | } 886| | else { 887| | auto [ptr, ec] = glz::from_chars(it, end, value); 888| | if (ec != std::errc()) [[unlikely]] { 889| | ctx.error = error_code::parse_number_failure; 890| | return; 891| | } 892| | it = ptr; 893| | } 894| | } 895| | } 896| | } 897| | 898| | if constexpr (check_quoted_num(Opts)) { 899| | if constexpr (not Opts.null_terminated) { 900| | if (it == end) [[unlikely]] { 901| | ctx.error = error_code::unexpected_end; 902| | return; 903| | } 904| | } 905| | if (match<'"'>(ctx, it)) { 906| | return; 907| | } 908| | if constexpr (not Opts.null_terminated) { 909| | if (it == end) { 910| | ctx.error = error_code::end_reached; 911| | return; 912| | } 913| | } 914| | } 915| 533k| else { 916| 533k| if constexpr (not Opts.null_terminated) { 917| 533k| if (it == end) { ------------------ | Branch (917:20): [True: 1.15k, False: 532k] ------------------ 918| 1.15k| ctx.error = error_code::end_reached; 919| 1.15k| return; 920| 1.15k| } 921| 533k| } 922| 533k| } 923| 533k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 52.2k| { 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| 52.2k| else { 60| 52.2k| using V = std::remove_cvref_t; 61| 52.2k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 52.2k| end); 63| 52.2k| } 64| 52.2k| } _ZN3glz4fromILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRiTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 808| 52.2k| { 809| | if constexpr (check_quoted_num(Opts)) { 810| | if (skip_ws(ctx, it, end)) { 811| | return; 812| | } 813| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 814| | return; 815| | } 816| | } 817| | 818| 52.2k| if constexpr (!check_ws_handled(Opts)) { 819| 52.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (819:17): [True: 128, False: 52.0k] ------------------ 820| 128| return; 821| 128| } 822| 52.2k| } 823| | 824| 52.0k| using V = std::decay_t; 825| 52.2k| if constexpr (int_t) { 826| 52.2k| static_assert(sizeof(*it) == sizeof(char)); 827| | 828| | if constexpr (Opts.null_terminated) { 829| | if (not glz::atoi(value, it)) [[unlikely]] { 830| | ctx.error = error_code::parse_number_failure; 831| | return; 832| | } 833| | } 834| 52.2k| else { 835| 52.2k| if (not glz::atoi(value, it, end)) [[unlikely]] { ------------------ | Branch (835:20): [True: 50.5k, False: 1.62k] ------------------ 836| 50.5k| ctx.error = error_code::parse_number_failure; 837| 50.5k| return; 838| 50.5k| } 839| 52.2k| } 840| | } 841| | else { 842| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 843| |#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 844| | if constexpr (is_float128) { 845| | auto [ptr, ec] = std::from_chars(it, end, value); 846| | if (ec != std::errc()) { 847| | ctx.error = error_code::parse_number_failure; 848| | return; 849| | } 850| | it = ptr; 851| | } 852| | else 853| |#endif 854| | { 855| | if constexpr (std::is_volatile_v>) { 856| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 857| | // place 858| | V temp; 859| | if constexpr (is_size_optimized(Opts)) { 860| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 861| | if (ec != std::errc{}) [[unlikely]] { 862| | ctx.error = error_code::parse_number_failure; 863| | return; 864| | } 865| | it = ptr; 866| | } 867| | else { 868| | auto [ptr, ec] = glz::from_chars(it, end, temp); 869| | if (ec != std::errc()) [[unlikely]] { 870| | ctx.error = error_code::parse_number_failure; 871| | return; 872| | } 873| | it = ptr; 874| | } 875| | value = temp; 876| | } 877| | else { 878| | if constexpr (is_size_optimized(Opts)) { 879| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 880| | if (ec != std::errc{}) [[unlikely]] { 881| | ctx.error = error_code::parse_number_failure; 882| | return; 883| | } 884| | it = ptr; 885| | } 886| | else { 887| | auto [ptr, ec] = glz::from_chars(it, end, value); 888| | if (ec != std::errc()) [[unlikely]] { 889| | ctx.error = error_code::parse_number_failure; 890| | return; 891| | } 892| | it = ptr; 893| | } 894| | } 895| | } 896| | } 897| | 898| | if constexpr (check_quoted_num(Opts)) { 899| | if constexpr (not Opts.null_terminated) { 900| | if (it == end) [[unlikely]] { 901| | ctx.error = error_code::unexpected_end; 902| | return; 903| | } 904| | } 905| | if (match<'"'>(ctx, it)) { 906| | return; 907| | } 908| | if constexpr (not Opts.null_terminated) { 909| | if (it == end) { 910| | ctx.error = error_code::end_reached; 911| | return; 912| | } 913| | } 914| | } 915| 52.2k| else { 916| 52.2k| if constexpr (not Opts.null_terminated) { 917| 52.2k| if (it == end) { ------------------ | Branch (917:20): [True: 764, False: 51.4k] ------------------ 918| 764| ctx.error = error_code::end_reached; 919| 764| return; 920| 764| } 921| 52.2k| } 922| 52.2k| } 923| 52.2k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 39.1k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 39.1k| else { 60| 39.1k| using V = std::remove_cvref_t; 61| 39.1k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 39.1k| end); 63| 39.1k| } 64| 39.1k| } _ZN3glz4fromILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 39.1k| { 3086| 39.1k| static constexpr auto num_members = reflect::size; 3087| | 3088| 39.1k| static constexpr auto Opts = opening_handled_off()>(); 3089| 39.1k| if constexpr (!check_opening_handled(Options)) { 3090| 39.1k| if constexpr (!check_ws_handled(Options)) { 3091| 39.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3091:20): [True: 98, False: 39.0k] ------------------ 3092| 98| return; 3093| 98| } 3094| 39.1k| } 3095| 39.1k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 15.3k, False: 23.8k] ------------------ 3096| 15.3k| return; 3097| 15.3k| } 3098| 23.8k| if constexpr (not Opts.null_terminated) { 3099| 23.8k| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 23.8k] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 23.8k| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 23.8k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 23.8k] ------------------ 3107| 0| return; 3108| 0| } 3109| 23.8k| } 3110| 23.8k| const auto ws_start = it; 3111| 39.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 73, False: 39.1k] ------------------ 3112| 73| return; 3113| 73| } 3114| 39.1k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 39.1k| else { 3189| 39.1k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 39.1k| if constexpr ((glaze_object_t || reflectable) && 3191| 39.1k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 39.1k| return bit_array{}; 3193| 39.1k| } 3194| 39.1k| else { 3195| 39.1k| return nullptr; 3196| 39.1k| } 3197| 39.1k| }(); 3198| | 3199| 39.1k| size_t read_count{}; // for partial_read 3200| | 3201| 39.1k| bool first = true; 3202| 99.9k| while (true) { ------------------ | Branch (3202:20): [True: 62.1k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 62.1k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 233, False: 61.9k] ------------------ 3240| 233| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 233| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 233| } 3265| 233| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 233| if constexpr (not Opts.null_terminated) { 3267| 233| if (it == end) { ------------------ | Branch (3267:26): [True: 129, False: 104] ------------------ 3268| 129| ctx.error = error_code::end_reached; 3269| 129| return; 3270| 129| } 3271| 233| } 3272| 104| return; 3273| 233| } 3274| 61.9k| else if (first) { ------------------ | Branch (3274:25): [True: 23.6k, False: 38.3k] ------------------ 3275| 23.6k| first = false; 3276| 23.6k| } 3277| 38.3k| else { 3278| 38.3k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 962, False: 37.3k] ------------------ 3279| 962| return; 3280| 962| } 3281| 37.3k| if constexpr (not Opts.null_terminated) { 3282| 37.3k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 37.3k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 37.3k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| 37.3k| (!Opts.comments)) { 3290| 37.3k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3290:26): [True: 31.6k, False: 5.67k] | Branch (3290:37): [True: 30.7k, False: 930] ------------------ 3291| 30.7k| skip_matching_ws(ws_start, it, ws_size); 3292| 30.7k| } 3293| 37.3k| } 3294| | 3295| 37.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 77, False: 37.2k] ------------------ 3296| 77| return; 3297| 77| } 3298| 37.3k| } 3299| | 3300| 60.9k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 60.9k| else if constexpr (reflection_type) { 3364| 60.9k| static_assert(bool(hash_info.type)); 3365| | 3366| 60.9k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 772, False: 60.1k] ------------------ 3367| 772| ctx.error = error_code::expected_quote; 3368| 772| return; 3369| 772| } 3370| 60.1k| ++it; 3371| 60.1k| if constexpr (not Opts.null_terminated) { 3372| 60.1k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 49, False: 60.0k] ------------------ 3373| 49| ctx.error = error_code::unexpected_end; 3374| 49| return; 3375| 49| } 3376| 60.1k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 60.1k| else { 3426| 60.1k| parse_and_invoke(value, ctx, it, end); 3427| 60.1k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 21.5k, False: 38.5k] ------------------ 3428| 21.5k| return; 3429| 60.1k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 60.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 71, False: 60.8k] ------------------ 3539| 71| return; 3540| 71| } 3541| 60.9k| } 3542| 39.1k| } 3543| 39.1k| } _ZZN3glz4fromILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 23.7k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 23.7k| else { 3195| 23.7k| return nullptr; 3196| 23.7k| } 3197| 23.7k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 364| 64.7k| { 365| 64.7k| constexpr auto N = reflect::size; 366| | 367| | if constexpr (N == 1) { 368| | decode_index(value, ctx, it, end, selected_index...); 369| | } 370| | else if constexpr (check_linear_search(Opts)) { 371| | // Linear search path 372| | auto key_start = it; 373| | const auto index = decode_linear(ctx, it, end); 374| | if (bool(ctx.error)) [[unlikely]] 375| | return; 376| | 377| | if (index >= N) [[unlikely]] { 378| | if constexpr (Opts.error_on_unknown_keys) { 379| | ctx.error = error_code::unknown_key; 380| | return; 381| | } 382| | else { 383| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 384| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 385| | return; 386| | } 387| | const sv key{key_start, size_t(it - key_start - 1)}; 388| | if constexpr (not Opts.null_terminated) { 389| | if (it == end) [[unlikely]] { 390| | ctx.error = error_code::unexpected_end; 391| | return; 392| | } 393| | } 394| | if (parse_ws_colon(ctx, it, end)) { 395| | return; 396| | } 397| | parse::handle_unknown(key, value, ctx, it, end); 398| | return; 399| | } 400| | } 401| | 402| | if constexpr (not Opts.null_terminated) { 403| | if (it == end) [[unlikely]] { 404| | ctx.error = error_code::unexpected_end; 405| | return; 406| | } 407| | } 408| | if (skip_ws(ctx, it, end)) { 409| | return; 410| | } 411| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 412| | return; 413| | } 414| | if (skip_ws(ctx, it, end)) { 415| | return; 416| | } 417| | 418| | // Fold expression dispatch - avoids jump table overhead for smaller binary size 419| | auto parse_field = [&]() { 420| | if constexpr (check_skip_null_members_on_read(Opts)) { 421| | if (*it == 'n') { 422| | ++it; 423| | if constexpr (not Opts.null_terminated) { 424| | if (it == end) [[unlikely]] { 425| | ctx.error = error_code::unexpected_end; 426| | return; 427| | } 428| | } 429| | match<"ull", Opts>(ctx, it, end); 430| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 431| | ((selected_index = I), ...); 432| | } 433| | return; 434| | } 435| | } 436| | 437| | // Check for operation-specific skipping 438| | if constexpr (meta_has_skip>) { 439| | constexpr auto Key = get(reflect::keys); 440| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 441| | skip_value::op(ctx, it, end); 442| | if (bool(ctx.error)) [[unlikely]] 443| | return; 444| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 445| | ((selected_index = I), ...); 446| | } 447| | return; 448| | } 449| | } 450| | 451| | using V = refl_t; 452| | if constexpr (const_value_v) { 453| | if constexpr (check_error_on_const_read(Opts)) { 454| | ctx.error = error_code::attempt_const_read; 455| | } 456| | else { 457| | skip_value::op(ctx, it, end); 458| | } 459| | } 460| | else { 461| | // For linear_search, use Opts directly to avoid duplicate template instantiations 462| | // We've already skipped whitespace before reaching here 463| | if constexpr (glaze_object_t) { 464| | from>::template op(get_member(value, get(reflect::values)), 465| | ctx, it, end); 466| | } 467| | else { 468| | from>::template op(get_member(value, get(to_tie(value))), ctx, 469| | it, end); 470| | } 471| | } 472| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 473| | ((selected_index = I), ...); 474| | } 475| | }; 476| | [&](std::index_sequence) { 477| | (void)(((index == Is ? (parse_field.template operator()(), true) : false) || ...)); 478| | }(std::make_index_sequence{}); 479| | } 480| 64.7k| else { 481| | // Hash-based lookup 482| 64.7k| constexpr auto& HashInfo = hash_info; 483| 64.7k| constexpr auto type = HashInfo.type; 484| 64.7k| static_assert(bool(type), "invalid hash algorithm"); 485| | 486| 64.7k| const auto index = decode_hash::op(it, end); 487| | 488| 64.7k| if (index >= N) [[unlikely]] { ------------------ | Branch (488:14): [True: 0, False: 64.7k] ------------------ 489| 0| if constexpr (Opts.error_on_unknown_keys) { 490| 0| ctx.error = error_code::unknown_key; 491| 0| return; 492| | } 493| | else { 494| | auto start = it; 495| | skip_string_view(ctx, it, end); 496| | if (bool(ctx.error)) [[unlikely]] 497| | return; 498| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 499| | return; 500| | const sv key = {start, size_t(it - start)}; 501| | ++it; // skip the quote 502| | if constexpr (not Opts.null_terminated) { 503| | if (it == end) [[unlikely]] { 504| | ctx.error = error_code::unexpected_end; 505| | return; 506| | } 507| | } 508| | if (parse_ws_colon(ctx, it, end)) { 509| | return; 510| | } 511| | parse::handle_unknown(key, value, ctx, it, end); 512| | return; 513| | } 514| 0| } 515| | 516| 64.7k| if constexpr (N == 2) { 517| 64.7k| if (index == 0) { ------------------ | Branch (517:17): [True: 28.3k, False: 36.3k] ------------------ 518| 28.3k| decode_index(value, ctx, it, end, selected_index...); 519| 28.3k| } 520| 36.3k| else { 521| 36.3k| decode_index(value, ctx, it, end, selected_index...); 522| 36.3k| } 523| | } 524| | else { 525| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 526| | } 527| 64.7k| } 528| 64.7k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 28.3k| { 235| 28.3k| static constexpr auto Key = get(reflect::keys); 236| 28.3k| static constexpr auto KeyWithEndQuote = join_v>; 237| 28.3k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 28.3k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 28.3k, False: 32] | Branch (239:36): [True: 28.2k, False: 72] ------------------ 240| 28.2k| it += Length; 241| 28.2k| if constexpr (not Opts.null_terminated) { 242| 28.2k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 28.2k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 28.2k| } 247| | 248| 28.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 22, False: 28.2k] ------------------ 249| 22| return; 250| 22| } 251| 28.2k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 87, False: 28.1k] ------------------ 252| 87| return; 253| 87| } 254| 28.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 31, False: 28.1k] ------------------ 255| 31| return; 256| 31| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 28.1k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 28.1k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 28.1k| else { 317| 28.1k| from>::template op()>( 318| 28.1k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 28.1k| } 320| 28.1k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 28.1k| } 326| 104| else [[unlikely]] { 327| 104| decode_index_unknown_key(value, ctx, it, end); 328| 104| } 329| 28.3k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 808| 287k| { 809| | if constexpr (check_quoted_num(Opts)) { 810| | if (skip_ws(ctx, it, end)) { 811| | return; 812| | } 813| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 814| | return; 815| | } 816| | } 817| | 818| | if constexpr (!check_ws_handled(Opts)) { 819| | if (skip_ws(ctx, it, end)) { 820| | return; 821| | } 822| | } 823| | 824| 287k| using V = std::decay_t; 825| | if constexpr (int_t) { 826| | static_assert(sizeof(*it) == sizeof(char)); 827| | 828| | if constexpr (Opts.null_terminated) { 829| | if (not glz::atoi(value, it)) [[unlikely]] { 830| | ctx.error = error_code::parse_number_failure; 831| | return; 832| | } 833| | } 834| | else { 835| | if (not glz::atoi(value, it, end)) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | } 840| | } 841| 287k| else { 842| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 843| 287k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 844| | if constexpr (is_float128) { 845| | auto [ptr, ec] = std::from_chars(it, end, value); 846| | if (ec != std::errc()) { 847| | ctx.error = error_code::parse_number_failure; 848| | return; 849| | } 850| | it = ptr; 851| | } 852| | else 853| |#endif 854| 287k| { 855| | if constexpr (std::is_volatile_v>) { 856| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 857| | // place 858| | V temp; 859| | if constexpr (is_size_optimized(Opts)) { 860| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 861| | if (ec != std::errc{}) [[unlikely]] { 862| | ctx.error = error_code::parse_number_failure; 863| | return; 864| | } 865| | it = ptr; 866| | } 867| | else { 868| | auto [ptr, ec] = glz::from_chars(it, end, temp); 869| | if (ec != std::errc()) [[unlikely]] { 870| | ctx.error = error_code::parse_number_failure; 871| | return; 872| | } 873| | it = ptr; 874| | } 875| | value = temp; 876| | } 877| 287k| else { 878| | if constexpr (is_size_optimized(Opts)) { 879| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 880| | if (ec != std::errc{}) [[unlikely]] { 881| | ctx.error = error_code::parse_number_failure; 882| | return; 883| | } 884| | it = ptr; 885| | } 886| 287k| else { 887| 287k| auto [ptr, ec] = glz::from_chars(it, end, value); 888| 287k| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (888:26): [True: 660, False: 286k] ------------------ 889| 660| ctx.error = error_code::parse_number_failure; 890| 660| return; 891| 660| } 892| 286k| it = ptr; 893| 286k| } 894| 287k| } 895| 287k| } 896| 287k| } 897| | 898| | if constexpr (check_quoted_num(Opts)) { 899| | if constexpr (not Opts.null_terminated) { 900| | if (it == end) [[unlikely]] { 901| | ctx.error = error_code::unexpected_end; 902| | return; 903| | } 904| | } 905| | if (match<'"'>(ctx, it)) { 906| | return; 907| | } 908| | if constexpr (not Opts.null_terminated) { 909| | if (it == end) { 910| | ctx.error = error_code::end_reached; 911| | return; 912| | } 913| | } 914| | } 915| 287k| else { 916| 287k| if constexpr (not Opts.null_terminated) { 917| 287k| if (it == end) { ------------------ | Branch (917:20): [True: 1.19k, False: 286k] ------------------ 918| 1.19k| ctx.error = error_code::end_reached; 919| 1.19k| return; 920| 1.19k| } 921| 287k| } 922| 287k| } 923| 287k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 20.7k| { 178| 20.7k| if constexpr (Opts.error_on_unknown_keys) { 179| 20.7k| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 20.7k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 36.3k| { 235| 36.3k| static constexpr auto Key = get(reflect::keys); 236| 36.3k| static constexpr auto KeyWithEndQuote = join_v>; 237| 36.3k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 36.3k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 36.1k, False: 212] | Branch (239:36): [True: 15.6k, False: 20.4k] ------------------ 240| 15.6k| it += Length; 241| 15.6k| if constexpr (not Opts.null_terminated) { 242| 15.6k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 15.6k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 15.6k| } 247| | 248| 15.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 26, False: 15.6k] ------------------ 249| 26| return; 250| 26| } 251| 15.6k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 71, False: 15.5k] ------------------ 252| 71| return; 253| 71| } 254| 15.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 25, False: 15.5k] ------------------ 255| 25| return; 256| 25| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 15.5k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 15.5k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 15.5k| else { 317| 15.5k| from>::template op()>( 318| 15.5k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 15.5k| } 320| 15.5k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 15.5k| } 326| 20.6k| else [[unlikely]] { 327| 20.6k| decode_index_unknown_key(value, ctx, it, end); 328| 20.6k| } 329| 36.3k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 26.3k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 26.3k| else { 60| 26.3k| using V = std::remove_cvref_t; 61| 26.3k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 26.3k| end); 63| 26.3k| } 64| 26.3k| } _ZN3glz4fromILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 26.3k| { 3086| 26.3k| static constexpr auto num_members = reflect::size; 3087| | 3088| 26.3k| static constexpr auto Opts = opening_handled_off()>(); 3089| 26.3k| if constexpr (!check_opening_handled(Options)) { 3090| 26.3k| if constexpr (!check_ws_handled(Options)) { 3091| 26.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3091:20): [True: 67, False: 26.2k] ------------------ 3092| 67| return; 3093| 67| } 3094| 26.3k| } 3095| 26.3k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 10.2k, False: 16.1k] ------------------ 3096| 10.2k| return; 3097| 10.2k| } 3098| 16.1k| if constexpr (not Opts.null_terminated) { 3099| 16.1k| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 16.1k] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 16.1k| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 16.1k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 16.1k] ------------------ 3107| 0| return; 3108| 0| } 3109| 16.1k| } 3110| 16.1k| const auto ws_start = it; 3111| 26.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 51, False: 26.2k] ------------------ 3112| 51| return; 3113| 51| } 3114| 26.2k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 26.2k| else { 3189| 26.2k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 26.2k| if constexpr ((glaze_object_t || reflectable) && 3191| 26.2k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 26.2k| return bit_array{}; 3193| 26.2k| } 3194| 26.2k| else { 3195| 26.2k| return nullptr; 3196| 26.2k| } 3197| 26.2k| }(); 3198| | 3199| 26.2k| size_t read_count{}; // for partial_read 3200| | 3201| 26.2k| bool first = true; 3202| 46.2k| while (true) { ------------------ | Branch (3202:20): [True: 20.5k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 20.5k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 400, False: 20.1k] ------------------ 3240| 400| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 400| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 400| } 3265| 400| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 400| if constexpr (not Opts.null_terminated) { 3267| 400| if (it == end) { ------------------ | Branch (3267:26): [True: 99, False: 301] ------------------ 3268| 99| ctx.error = error_code::end_reached; 3269| 99| return; 3270| 99| } 3271| 400| } 3272| 301| return; 3273| 400| } 3274| 20.1k| else if (first) { ------------------ | Branch (3274:25): [True: 15.9k, False: 4.18k] ------------------ 3275| 15.9k| first = false; 3276| 15.9k| } 3277| 4.18k| else { 3278| 4.18k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 138, False: 4.04k] ------------------ 3279| 138| return; 3280| 138| } 3281| 4.04k| if constexpr (not Opts.null_terminated) { 3282| 4.04k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 4.04k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 4.04k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| 4.04k| (!Opts.comments)) { 3290| 4.04k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3290:26): [True: 3.82k, False: 220] | Branch (3290:37): [True: 3.75k, False: 70] ------------------ 3291| 3.75k| skip_matching_ws(ws_start, it, ws_size); 3292| 3.75k| } 3293| 4.04k| } 3294| | 3295| 4.04k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 35, False: 4.01k] ------------------ 3296| 35| return; 3297| 35| } 3298| 4.04k| } 3299| | 3300| 19.9k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 19.9k| else if constexpr (reflection_type) { 3364| 19.9k| static_assert(bool(hash_info.type)); 3365| | 3366| 19.9k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 734, False: 19.2k] ------------------ 3367| 734| ctx.error = error_code::expected_quote; 3368| 734| return; 3369| 734| } 3370| 19.2k| ++it; 3371| 19.2k| if constexpr (not Opts.null_terminated) { 3372| 19.2k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 20, False: 19.2k] ------------------ 3373| 20| ctx.error = error_code::unexpected_end; 3374| 20| return; 3375| 20| } 3376| 19.2k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 19.2k| else { 3426| 19.2k| parse_and_invoke(value, ctx, it, end); 3427| 19.2k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 14.6k, False: 4.57k] ------------------ 3428| 14.6k| return; 3429| 19.2k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 19.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 30, False: 19.9k] ------------------ 3539| 30| return; 3540| 30| } 3541| 19.9k| } 3542| 26.2k| } 3543| 26.2k| } _ZZN3glz4fromILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 16.0k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 16.0k| else { 3195| 16.0k| return nullptr; 3196| 16.0k| } 3197| 16.0k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 364| 22.1k| { 365| 22.1k| constexpr auto N = reflect::size; 366| | 367| | if constexpr (N == 1) { 368| | decode_index(value, ctx, it, end, selected_index...); 369| | } 370| | else if constexpr (check_linear_search(Opts)) { 371| | // Linear search path 372| | auto key_start = it; 373| | const auto index = decode_linear(ctx, it, end); 374| | if (bool(ctx.error)) [[unlikely]] 375| | return; 376| | 377| | if (index >= N) [[unlikely]] { 378| | if constexpr (Opts.error_on_unknown_keys) { 379| | ctx.error = error_code::unknown_key; 380| | return; 381| | } 382| | else { 383| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 384| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 385| | return; 386| | } 387| | const sv key{key_start, size_t(it - key_start - 1)}; 388| | if constexpr (not Opts.null_terminated) { 389| | if (it == end) [[unlikely]] { 390| | ctx.error = error_code::unexpected_end; 391| | return; 392| | } 393| | } 394| | if (parse_ws_colon(ctx, it, end)) { 395| | return; 396| | } 397| | parse::handle_unknown(key, value, ctx, it, end); 398| | return; 399| | } 400| | } 401| | 402| | if constexpr (not Opts.null_terminated) { 403| | if (it == end) [[unlikely]] { 404| | ctx.error = error_code::unexpected_end; 405| | return; 406| | } 407| | } 408| | if (skip_ws(ctx, it, end)) { 409| | return; 410| | } 411| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 412| | return; 413| | } 414| | if (skip_ws(ctx, it, end)) { 415| | return; 416| | } 417| | 418| | // Fold expression dispatch - avoids jump table overhead for smaller binary size 419| | auto parse_field = [&]() { 420| | if constexpr (check_skip_null_members_on_read(Opts)) { 421| | if (*it == 'n') { 422| | ++it; 423| | if constexpr (not Opts.null_terminated) { 424| | if (it == end) [[unlikely]] { 425| | ctx.error = error_code::unexpected_end; 426| | return; 427| | } 428| | } 429| | match<"ull", Opts>(ctx, it, end); 430| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 431| | ((selected_index = I), ...); 432| | } 433| | return; 434| | } 435| | } 436| | 437| | // Check for operation-specific skipping 438| | if constexpr (meta_has_skip>) { 439| | constexpr auto Key = get(reflect::keys); 440| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 441| | skip_value::op(ctx, it, end); 442| | if (bool(ctx.error)) [[unlikely]] 443| | return; 444| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 445| | ((selected_index = I), ...); 446| | } 447| | return; 448| | } 449| | } 450| | 451| | using V = refl_t; 452| | if constexpr (const_value_v) { 453| | if constexpr (check_error_on_const_read(Opts)) { 454| | ctx.error = error_code::attempt_const_read; 455| | } 456| | else { 457| | skip_value::op(ctx, it, end); 458| | } 459| | } 460| | else { 461| | // For linear_search, use Opts directly to avoid duplicate template instantiations 462| | // We've already skipped whitespace before reaching here 463| | if constexpr (glaze_object_t) { 464| | from>::template op(get_member(value, get(reflect::values)), 465| | ctx, it, end); 466| | } 467| | else { 468| | from>::template op(get_member(value, get(to_tie(value))), ctx, 469| | it, end); 470| | } 471| | } 472| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 473| | ((selected_index = I), ...); 474| | } 475| | }; 476| | [&](std::index_sequence) { 477| | (void)(((index == Is ? (parse_field.template operator()(), true) : false) || ...)); 478| | }(std::make_index_sequence{}); 479| | } 480| 22.1k| else { 481| | // Hash-based lookup 482| 22.1k| constexpr auto& HashInfo = hash_info; 483| 22.1k| constexpr auto type = HashInfo.type; 484| 22.1k| static_assert(bool(type), "invalid hash algorithm"); 485| | 486| 22.1k| const auto index = decode_hash::op(it, end); 487| | 488| 22.1k| if (index >= N) [[unlikely]] { ------------------ | Branch (488:14): [True: 0, False: 22.1k] ------------------ 489| 0| if constexpr (Opts.error_on_unknown_keys) { 490| 0| ctx.error = error_code::unknown_key; 491| 0| return; 492| | } 493| | else { 494| | auto start = it; 495| | skip_string_view(ctx, it, end); 496| | if (bool(ctx.error)) [[unlikely]] 497| | return; 498| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 499| | return; 500| | const sv key = {start, size_t(it - start)}; 501| | ++it; // skip the quote 502| | if constexpr (not Opts.null_terminated) { 503| | if (it == end) [[unlikely]] { 504| | ctx.error = error_code::unexpected_end; 505| | return; 506| | } 507| | } 508| | if (parse_ws_colon(ctx, it, end)) { 509| | return; 510| | } 511| | parse::handle_unknown(key, value, ctx, it, end); 512| | return; 513| | } 514| 0| } 515| | 516| 22.1k| if constexpr (N == 2) { 517| 22.1k| if (index == 0) { ------------------ | Branch (517:17): [True: 204, False: 21.9k] ------------------ 518| 204| decode_index(value, ctx, it, end, selected_index...); 519| 204| } 520| 21.9k| else { 521| 21.9k| decode_index(value, ctx, it, end, selected_index...); 522| 21.9k| } 523| | } 524| | else { 525| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 526| | } 527| 22.1k| } 528| 22.1k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 204| { 235| 204| static constexpr auto Key = get(reflect::keys); 236| 204| static constexpr auto KeyWithEndQuote = join_v>; 237| 204| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 204| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 194, False: 10] | Branch (239:36): [True: 0, False: 194] ------------------ 240| 0| it += Length; 241| 0| if constexpr (not Opts.null_terminated) { 242| 0| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 0] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 0| } 247| | 248| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 0, False: 0] ------------------ 249| 0| return; 250| 0| } 251| 0| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 0, False: 0] ------------------ 252| 0| return; 253| 0| } 254| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 0, False: 0] ------------------ 255| 0| return; 256| 0| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 0| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 0| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 0| else { 317| 0| from>::template op()>( 318| 0| get_member(value, get(to_tie(value))), ctx, it, end); 319| 0| } 320| 0| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 0| } 326| 204| else [[unlikely]] { 327| 204| decode_index_unknown_key(value, ctx, it, end); 328| 204| } 329| 204| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 14.1k| { 178| 14.1k| if constexpr (Opts.error_on_unknown_keys) { 179| 14.1k| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 14.1k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 21.9k| { 235| 21.9k| static constexpr auto Key = get(reflect::keys); 236| 21.9k| static constexpr auto KeyWithEndQuote = join_v>; 237| 21.9k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 21.9k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 21.2k, False: 707] | Branch (239:36): [True: 7.96k, False: 13.2k] ------------------ 240| 7.96k| it += Length; 241| 7.96k| if constexpr (not Opts.null_terminated) { 242| 7.96k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 7.96k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 7.96k| } 247| | 248| 7.96k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 24, False: 7.93k] ------------------ 249| 24| return; 250| 24| } 251| 7.93k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 62, False: 7.87k] ------------------ 252| 62| return; 253| 62| } 254| 7.87k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 25, False: 7.85k] ------------------ 255| 25| return; 256| 25| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 7.85k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 7.85k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 7.85k| else { 317| 7.85k| from>::template op()>( 318| 7.85k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 7.85k| } 320| 7.85k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 7.85k| } 326| 13.9k| else [[unlikely]] { 327| 13.9k| decode_index_unknown_key(value, ctx, it, end); 328| 13.9k| } 329| 21.9k| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_: 1084| 12.3k| { 1085| | if constexpr (check_string_as_number(Opts)) { 1086| | auto start = it; 1087| | skip_number(ctx, it, end); 1088| | if (bool(ctx.error)) [[unlikely]] { 1089| | return; 1090| | } 1091| | if (start == it) [[unlikely]] { 1092| | ctx.error = error_code::parse_number_failure; 1093| | return; 1094| | } 1095| | value.append(start, size_t(it - start)); 1096| | } 1097| 12.3k| else { 1098| 12.3k| if constexpr (!check_opening_handled(Opts)) { 1099| | if constexpr (!check_ws_handled(Opts)) { 1100| | if (skip_ws(ctx, it, end)) { 1101| | return; 1102| | } 1103| | } 1104| | 1105| 12.3k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1105:20): [True: 56, False: 12.2k] ------------------ 1106| 56| return; 1107| 56| } 1108| 12.3k| } 1109| | 1110| 12.3k| if constexpr (not check_raw_string(Opts)) { 1111| 12.3k| static constexpr auto string_padding_bytes = 8; 1112| | 1113| 12.3k| if (size_t(end - it) >= 8) { ------------------ | Branch (1113:20): [True: 11.6k, False: 683] ------------------ 1114| 11.6k| auto start = it; 1115| 11.6k| uint64_t ascii_acc{}; 1116| 11.6k| const auto end8 = end - 8; 1117| 3.91M| while (true) { ------------------ | Branch (1117:26): [True: 3.91M, Folded] ------------------ 1118| 3.91M| if (it >= end8) [[unlikely]] { ------------------ | Branch (1118:26): [True: 811, False: 3.91M] ------------------ 1119| 811| break; 1120| 811| } 1121| | 1122| 3.91M| uint64_t chunk; 1123| 3.91M| std::memcpy(&chunk, it, 8); 1124| | if constexpr (std::endian::native == std::endian::big) { 1125| | chunk = std::byteswap(chunk); 1126| | } 1127| 3.91M| ascii_acc |= chunk; 1128| 3.91M| const uint64_t test_chars = has_quote(chunk); 1129| 3.91M| if (test_chars) { ------------------ | Branch (1129:26): [True: 11.8k, False: 3.90M] ------------------ 1130| 11.8k| it += (countr_zero(test_chars) >> 3); 1131| | 1132| 11.8k| auto* prev = it - 1; 1133| 23.4k| while (*prev == '\\') { ------------------ | Branch (1133:32): [True: 11.5k, False: 11.8k] ------------------ 1134| 11.5k| --prev; 1135| 11.5k| } 1136| 11.8k| if (size_t(it - prev) % 2) { ------------------ | Branch (1136:29): [True: 10.8k, False: 1.01k] ------------------ 1137| 10.8k| goto continue_decode; 1138| 10.8k| } 1139| 1.01k| ++it; // skip the escaped quote 1140| 1.01k| } 1141| 3.90M| else { 1142| 3.90M| it += 8; 1143| 3.90M| } 1144| 3.91M| } 1145| | 1146| 1.97k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (1146:26): [True: 1.16k, False: 811] ------------------ 1147| | // if we ended on an escape character then we need to rewind 1148| | // because we lost our context 1149| 1.16k| --it; 1150| 1.16k| } 1151| | 1152| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 1153| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 1154| 4.68k| for (; it < end; ++it) { ------------------ | Branch (1154:26): [True: 4.62k, False: 63] ------------------ 1155| 4.62k| ascii_acc |= uint8_t(*it); 1156| 4.62k| if (*it == '"') { ------------------ | Branch (1156:26): [True: 797, False: 3.82k] ------------------ 1157| 797| auto* prev = it - 1; 1158| 1.45k| while (*prev == '\\') { ------------------ | Branch (1158:32): [True: 653, False: 797] ------------------ 1159| 653| --prev; 1160| 653| } 1161| 797| if (size_t(it - prev) % 2) { ------------------ | Branch (1161:29): [True: 748, False: 49] ------------------ 1162| 748| goto continue_decode; 1163| 748| } 1164| 797| } 1165| 4.62k| } 1166| | 1167| 63| ctx.error = error_code::unexpected_end; 1168| 63| return; 1169| | 1170| 11.5k| continue_decode: 1171| | 1172| 11.5k| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1172:23): [True: 253, False: 11.3k] ------------------ 1173| 253| return; 1174| 253| } 1175| | 1176| 11.3k| const auto available_padding = size_t(end - it); 1177| 11.3k| auto n = size_t(it - start); 1178| 11.3k| if (available_padding >= 8) [[likely]] { ------------------ | Branch (1178:23): [True: 10.7k, False: 629] ------------------ 1179| 10.7k| value.resize(n + string_padding_bytes); 1180| | 1181| 10.7k| auto* p = value.data(); 1182| | 1183| 2.89M| while (true) { ------------------ | Branch (1183:29): [True: 2.89M, Folded] ------------------ 1184| 2.89M| if (start >= it) { ------------------ | Branch (1184:29): [True: 7.99k, False: 2.88M] ------------------ 1185| 7.99k| break; 1186| 7.99k| } 1187| | 1188| 2.88M| std::memcpy(p, start, 8); 1189| 2.88M| uint64_t swar; 1190| 2.88M| std::memcpy(&swar, p, 8); 1191| | if constexpr (std::endian::native == std::endian::big) { 1192| | swar = std::byteswap(swar); 1193| | } 1194| | 1195| 2.88M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1196| 2.88M| const uint64_t lo7 = swar & lo7_mask; 1197| 2.88M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1198| 2.88M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1199| 2.88M| uint64_t next = ~((backslash & less_32) | swar); 1200| | 1201| 2.88M| next &= repeat_byte8(0b10000000); 1202| 2.88M| if (next == 0) { ------------------ | Branch (1202:29): [True: 2.76M, False: 120k] ------------------ 1203| 2.76M| start += 8; 1204| 2.76M| p += 8; 1205| 2.76M| continue; 1206| 2.76M| } 1207| | 1208| 120k| next = countr_zero(next) >> 3; 1209| 120k| start += next; 1210| 120k| if (start >= it) { ------------------ | Branch (1210:29): [True: 2.52k, False: 117k] ------------------ 1211| 2.52k| break; 1212| 2.52k| } 1213| | 1214| 117k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1214:29): [True: 88, False: 117k] ------------------ 1215| 88| ctx.error = error_code::syntax_error; 1216| 88| return; 1217| 88| } 1218| 117k| ++start; // skip the escape 1219| 117k| if (*start == 'u') { ------------------ | Branch (1219:29): [True: 31.9k, False: 85.6k] ------------------ 1220| 31.9k| ++start; 1221| 31.9k| p += next; 1222| 31.9k| const auto mark = start; 1223| 31.9k| const auto offset = handle_unicode_code_point(start, p, end); 1224| 31.9k| if (offset == 0) [[unlikely]] { ------------------ | Branch (1224:32): [True: 88, False: 31.8k] ------------------ 1225| 88| ctx.error = error_code::unicode_escape_conversion_failure; 1226| 88| return; 1227| 88| } 1228| 31.8k| n += offset; 1229| | // escape + u + unicode code points 1230| 31.8k| n -= 2 + uint32_t(start - mark); 1231| 31.8k| } 1232| 85.6k| else { 1233| 85.6k| p += next; 1234| 85.6k| *p = char_unescape_table[uint8_t(*start)]; 1235| 85.6k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1235:32): [True: 20, False: 85.6k] ------------------ 1236| 20| ctx.error = error_code::invalid_escape; 1237| 20| return; 1238| 20| } 1239| 85.6k| ++p; 1240| 85.6k| ++start; 1241| 85.6k| --n; 1242| 85.6k| } 1243| 117k| } 1244| | 1245| 10.5k| value.resize(n); 1246| 10.5k| ++it; 1247| 10.5k| } 1248| 629| else { 1249| | // For large inputs this case of running out of buffer is very rare 1250| 629| value.resize(n); 1251| 629| auto* p = value.data(); 1252| | 1253| 629| it = start; 1254| 131k| while (it < end) [[likely]] { ------------------ | Branch (1254:29): [True: 131k, False: 0] ------------------ 1255| 131k| if (*it == '"') { ------------------ | Branch (1255:29): [True: 417, False: 131k] ------------------ 1256| 417| value.resize(size_t(p - value.data())); 1257| 417| ++it; 1258| 417| return; 1259| 417| } 1260| | 1261| 131k| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1261:29): [True: 79, False: 131k] ------------------ 1262| 79| ctx.error = error_code::syntax_error; 1263| 79| return; 1264| 79| } 1265| | 1266| 131k| *p = *it; 1267| | 1268| 131k| if (*it == '\\') { ------------------ | Branch (1268:29): [True: 6.23k, False: 124k] ------------------ 1269| 6.23k| ++it; // skip the escape 1270| 6.23k| if (*it == 'u') { ------------------ | Branch (1270:32): [True: 1.91k, False: 4.32k] ------------------ 1271| 1.91k| ++it; 1272| 1.91k| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1272:35): [True: 111, False: 1.79k] ------------------ 1273| 111| ctx.error = error_code::unicode_escape_conversion_failure; 1274| 111| return; 1275| 111| } 1276| 1.91k| } 1277| 4.32k| else { 1278| 4.32k| *p = char_unescape_table[uint8_t(*it)]; 1279| 4.32k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1279:35): [True: 22, False: 4.30k] ------------------ 1280| 22| ctx.error = error_code::invalid_escape; 1281| 22| return; 1282| 22| } 1283| 4.30k| ++p; 1284| 4.30k| ++it; 1285| 4.30k| } 1286| 6.23k| } 1287| 124k| else { 1288| 124k| ++it; 1289| 124k| ++p; 1290| 124k| } 1291| 131k| } 1292| | 1293| 0| ctx.error = error_code::unexpected_end; 1294| 0| } 1295| 11.3k| } 1296| 683| else { 1297| | // For short strings 1298| | 1299| 683| std::array buffer{}; 1300| | 1301| 683| auto* p = buffer.data(); 1302| 683| const auto* const utf8_start = it; 1303| | 1304| 1.82k| while (it < end) [[likely]] { ------------------ | Branch (1304:26): [True: 1.66k, False: 159] ------------------ 1305| 1.66k| *p = *it; 1306| 1.66k| if (*it == '"') { ------------------ | Branch (1306:26): [True: 447, False: 1.21k] ------------------ 1307| 447| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1307:29): [True: 154, False: 293] ------------------ 1308| 154| return; 1309| 154| } 1310| 293| const size_t n = size_t(p - buffer.data()); 1311| 293|#if __has_cpp_attribute(assume) >= 202207L 1312| 293| [[assume(n <= sizeof(buffer))]]; 1313| 293|#endif 1314| 293| value.assign(buffer.data(), n); 1315| 293| ++it; 1316| 293| if constexpr (not Opts.null_terminated) { 1317| 293| if (it == end) { ------------------ | Branch (1317:32): [True: 100, False: 193] ------------------ 1318| 100| ctx.error = error_code::end_reached; 1319| 100| return; 1320| 100| } 1321| 293| } 1322| 193| return; 1323| 447| } 1324| 1.21k| else if (*it == '\\') { ------------------ | Branch (1324:31): [True: 162, False: 1.05k] ------------------ 1325| 162| ++it; // skip the escape 1326| 162| if constexpr (not Opts.null_terminated) { 1327| 162| if (it == end) [[unlikely]] { ------------------ | Branch (1327:32): [True: 9, False: 153] ------------------ 1328| 9| ctx.error = error_code::unexpected_end; 1329| 9| return; 1330| 9| } 1331| 162| } 1332| 162| if (*it == 'u') { ------------------ | Branch (1332:29): [True: 94, False: 68] ------------------ 1333| 94| ++it; 1334| 94| if constexpr (not Opts.null_terminated) { 1335| 94| if (it == end) [[unlikely]] { ------------------ | Branch (1335:35): [True: 7, False: 87] ------------------ 1336| 7| ctx.error = error_code::unexpected_end; 1337| 7| return; 1338| 7| } 1339| 94| } 1340| 94| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1340:32): [True: 31, False: 63] ------------------ 1341| 31| ctx.error = error_code::unicode_escape_conversion_failure; 1342| 31| return; 1343| 31| } 1344| 94| } 1345| 68| else { 1346| 68| *p = char_unescape_table[uint8_t(*it)]; 1347| 68| if (*p == 0) [[unlikely]] { ------------------ | Branch (1347:32): [True: 13, False: 55] ------------------ 1348| 13| ctx.error = error_code::invalid_escape; 1349| 13| return; 1350| 13| } 1351| 55| ++p; 1352| 55| ++it; 1353| 55| } 1354| 162| } 1355| 1.05k| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1355:31): [True: 33, False: 1.02k] ------------------ 1356| 33| ctx.error = error_code::syntax_error; 1357| 33| return; 1358| 33| } 1359| 1.02k| else { 1360| 1.02k| ++it; 1361| 1.02k| ++p; 1362| 1.02k| } 1363| 1.66k| } 1364| | 1365| 159| ctx.error = error_code::unexpected_end; 1366| 159| } 1367| | } 1368| | else { 1369| | // raw_string 1370| | auto start = it; 1371| | skip_string_view(ctx, it, end); 1372| | if (bool(ctx.error)) [[unlikely]] 1373| | return; 1374| | 1375| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1376| | return; 1377| | } 1378| | 1379| | value.assign(start, size_t(it - start)); 1380| | ++it; 1381| | } 1382| 12.3k| } 1383| 12.3k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 22.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 22.0k| else { 60| 22.0k| using V = std::remove_cvref_t; 61| 22.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 22.0k| end); 63| 22.0k| } 64| 22.0k| } _ZN3glz4fromILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 22.0k| { 3086| 22.0k| static constexpr auto num_members = reflect::size; 3087| | 3088| 22.0k| static constexpr auto Opts = opening_handled_off()>(); 3089| 22.0k| if constexpr (!check_opening_handled(Options)) { 3090| 22.0k| if constexpr (!check_ws_handled(Options)) { 3091| 22.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3091:20): [True: 50, False: 22.0k] ------------------ 3092| 50| return; 3093| 50| } 3094| 22.0k| } 3095| 22.0k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 7.95k, False: 14.1k] ------------------ 3096| 7.95k| return; 3097| 7.95k| } 3098| 14.1k| if constexpr (not Opts.null_terminated) { 3099| 14.1k| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 14.1k] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 14.1k| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 14.1k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 14.1k] ------------------ 3107| 0| return; 3108| 0| } 3109| 14.1k| } 3110| 14.1k| const auto ws_start = it; 3111| 22.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 38, False: 22.0k] ------------------ 3112| 38| return; 3113| 38| } 3114| 22.0k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 22.0k| else { 3189| 22.0k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 22.0k| if constexpr ((glaze_object_t || reflectable) && 3191| 22.0k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 22.0k| return bit_array{}; 3193| 22.0k| } 3194| 22.0k| else { 3195| 22.0k| return nullptr; 3196| 22.0k| } 3197| 22.0k| }(); 3198| | 3199| 22.0k| size_t read_count{}; // for partial_read 3200| | 3201| 22.0k| bool first = true; 3202| 91.1k| while (true) { ------------------ | Branch (3202:20): [True: 69.7k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 69.7k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 52, False: 69.6k] ------------------ 3240| 52| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 52| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 52| } 3265| 52| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 52| if constexpr (not Opts.null_terminated) { 3267| 52| if (it == end) { ------------------ | Branch (3267:26): [True: 19, False: 33] ------------------ 3268| 19| ctx.error = error_code::end_reached; 3269| 19| return; 3270| 19| } 3271| 52| } 3272| 33| return; 3273| 52| } 3274| 69.6k| else if (first) { ------------------ | Branch (3274:25): [True: 13.9k, False: 55.6k] ------------------ 3275| 13.9k| first = false; 3276| 13.9k| } 3277| 55.6k| else { 3278| 55.6k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 374, False: 55.2k] ------------------ 3279| 374| return; 3280| 374| } 3281| 55.2k| if constexpr (not Opts.null_terminated) { 3282| 55.2k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 55.2k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 55.2k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| 55.2k| (!Opts.comments)) { 3290| 55.2k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3290:26): [True: 39.0k, False: 16.2k] | Branch (3290:37): [True: 38.7k, False: 274] ------------------ 3291| 38.7k| skip_matching_ws(ws_start, it, ws_size); 3292| 38.7k| } 3293| 55.2k| } 3294| | 3295| 55.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 65, False: 55.2k] ------------------ 3296| 65| return; 3297| 65| } 3298| 55.2k| } 3299| | 3300| 69.2k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 69.2k| else if constexpr (reflection_type) { 3364| 69.2k| static_assert(bool(hash_info.type)); 3365| | 3366| 69.2k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 730, False: 68.4k] ------------------ 3367| 730| ctx.error = error_code::expected_quote; 3368| 730| return; 3369| 730| } 3370| 68.4k| ++it; 3371| 68.4k| if constexpr (not Opts.null_terminated) { 3372| 68.4k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 22, False: 68.4k] ------------------ 3373| 22| ctx.error = error_code::unexpected_end; 3374| 22| return; 3375| 22| } 3376| 68.4k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 68.4k| else { 3426| 68.4k| parse_and_invoke(value, ctx, it, end); 3427| 68.4k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 12.7k, False: 55.7k] ------------------ 3428| 12.7k| return; 3429| 68.4k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 69.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 92, False: 69.1k] ------------------ 3539| 92| return; 3540| 92| } 3541| 69.2k| } 3542| 22.0k| } 3543| 22.0k| } _ZZN3glz4fromILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 14.0k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 14.0k| else { 3195| 14.0k| return nullptr; 3196| 14.0k| } 3197| 14.0k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 364| 68.4k| { 365| 68.4k| constexpr auto N = reflect::size; 366| | 367| | if constexpr (N == 1) { 368| | decode_index(value, ctx, it, end, selected_index...); 369| | } 370| | else if constexpr (check_linear_search(Opts)) { 371| | // Linear search path 372| | auto key_start = it; 373| | const auto index = decode_linear(ctx, it, end); 374| | if (bool(ctx.error)) [[unlikely]] 375| | return; 376| | 377| | if (index >= N) [[unlikely]] { 378| | if constexpr (Opts.error_on_unknown_keys) { 379| | ctx.error = error_code::unknown_key; 380| | return; 381| | } 382| | else { 383| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 384| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 385| | return; 386| | } 387| | const sv key{key_start, size_t(it - key_start - 1)}; 388| | if constexpr (not Opts.null_terminated) { 389| | if (it == end) [[unlikely]] { 390| | ctx.error = error_code::unexpected_end; 391| | return; 392| | } 393| | } 394| | if (parse_ws_colon(ctx, it, end)) { 395| | return; 396| | } 397| | parse::handle_unknown(key, value, ctx, it, end); 398| | return; 399| | } 400| | } 401| | 402| | if constexpr (not Opts.null_terminated) { 403| | if (it == end) [[unlikely]] { 404| | ctx.error = error_code::unexpected_end; 405| | return; 406| | } 407| | } 408| | if (skip_ws(ctx, it, end)) { 409| | return; 410| | } 411| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 412| | return; 413| | } 414| | if (skip_ws(ctx, it, end)) { 415| | return; 416| | } 417| | 418| | // Fold expression dispatch - avoids jump table overhead for smaller binary size 419| | auto parse_field = [&]() { 420| | if constexpr (check_skip_null_members_on_read(Opts)) { 421| | if (*it == 'n') { 422| | ++it; 423| | if constexpr (not Opts.null_terminated) { 424| | if (it == end) [[unlikely]] { 425| | ctx.error = error_code::unexpected_end; 426| | return; 427| | } 428| | } 429| | match<"ull", Opts>(ctx, it, end); 430| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 431| | ((selected_index = I), ...); 432| | } 433| | return; 434| | } 435| | } 436| | 437| | // Check for operation-specific skipping 438| | if constexpr (meta_has_skip>) { 439| | constexpr auto Key = get(reflect::keys); 440| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 441| | skip_value::op(ctx, it, end); 442| | if (bool(ctx.error)) [[unlikely]] 443| | return; 444| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 445| | ((selected_index = I), ...); 446| | } 447| | return; 448| | } 449| | } 450| | 451| | using V = refl_t; 452| | if constexpr (const_value_v) { 453| | if constexpr (check_error_on_const_read(Opts)) { 454| | ctx.error = error_code::attempt_const_read; 455| | } 456| | else { 457| | skip_value::op(ctx, it, end); 458| | } 459| | } 460| | else { 461| | // For linear_search, use Opts directly to avoid duplicate template instantiations 462| | // We've already skipped whitespace before reaching here 463| | if constexpr (glaze_object_t) { 464| | from>::template op(get_member(value, get(reflect::values)), 465| | ctx, it, end); 466| | } 467| | else { 468| | from>::template op(get_member(value, get(to_tie(value))), ctx, 469| | it, end); 470| | } 471| | } 472| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 473| | ((selected_index = I), ...); 474| | } 475| | }; 476| | [&](std::index_sequence) { 477| | (void)(((index == Is ? (parse_field.template operator()(), true) : false) || ...)); 478| | }(std::make_index_sequence{}); 479| | } 480| 68.4k| else { 481| | // Hash-based lookup 482| 68.4k| constexpr auto& HashInfo = hash_info; 483| 68.4k| constexpr auto type = HashInfo.type; 484| 68.4k| static_assert(bool(type), "invalid hash algorithm"); 485| | 486| 68.4k| const auto index = decode_hash::op(it, end); 487| | 488| 68.4k| if (index >= N) [[unlikely]] { ------------------ | Branch (488:14): [True: 4.56k, False: 63.8k] ------------------ 489| 4.56k| if constexpr (Opts.error_on_unknown_keys) { 490| 4.56k| ctx.error = error_code::unknown_key; 491| 4.56k| return; 492| | } 493| | else { 494| | auto start = it; 495| | skip_string_view(ctx, it, end); 496| | if (bool(ctx.error)) [[unlikely]] 497| | return; 498| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 499| | return; 500| | const sv key = {start, size_t(it - start)}; 501| | ++it; // skip the quote 502| | if constexpr (not Opts.null_terminated) { 503| | if (it == end) [[unlikely]] { 504| | ctx.error = error_code::unexpected_end; 505| | return; 506| | } 507| | } 508| | if (parse_ws_colon(ctx, it, end)) { 509| | return; 510| | } 511| | parse::handle_unknown(key, value, ctx, it, end); 512| | return; 513| | } 514| 4.56k| } 515| | 516| | if constexpr (N == 2) { 517| | if (index == 0) { 518| | decode_index(value, ctx, it, end, selected_index...); 519| | } 520| | else { 521| | decode_index(value, ctx, it, end, selected_index...); 522| | } 523| | } 524| 68.4k| else { 525| 68.4k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 526| 68.4k| } 527| 68.4k| } 528| 68.4k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm0EEEDav: 525| 38.4k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 38.4k| { 235| 38.4k| static constexpr auto Key = get(reflect::keys); 236| 38.4k| static constexpr auto KeyWithEndQuote = join_v>; 237| 38.4k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 38.4k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 38.4k, False: 18] | Branch (239:36): [True: 38.3k, False: 109] ------------------ 240| 38.3k| it += Length; 241| 38.3k| if constexpr (not Opts.null_terminated) { 242| 38.3k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 38.3k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 38.3k| } 247| | 248| 38.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 20, False: 38.3k] ------------------ 249| 20| return; 250| 20| } 251| 38.3k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 35, False: 38.2k] ------------------ 252| 35| return; 253| 35| } 254| 38.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 20, False: 38.2k] ------------------ 255| 20| return; 256| 20| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 38.2k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 38.2k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 38.2k| else { 317| 38.2k| from>::template op()>( 318| 38.2k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 38.2k| } 320| 38.2k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 38.2k| } 326| 127| else [[unlikely]] { 327| 127| decode_index_unknown_key(value, ctx, it, end); 328| 127| } 329| 38.4k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 882| { 178| 882| if constexpr (Opts.error_on_unknown_keys) { 179| 882| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 882| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm1EEEDav: 525| 144| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm1ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 144| { 235| 144| static constexpr auto Key = get(reflect::keys); 236| 144| static constexpr auto KeyWithEndQuote = join_v>; 237| 144| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 144| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 139, False: 5] | Branch (239:36): [True: 67, False: 72] ------------------ 240| 67| it += Length; 241| 67| if constexpr (not Opts.null_terminated) { 242| 67| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 67] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 67| } 247| | 248| 67| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 13, False: 54] ------------------ 249| 13| return; 250| 13| } 251| 54| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 23, False: 31] ------------------ 252| 23| return; 253| 23| } 254| 31| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 12, False: 19] ------------------ 255| 12| return; 256| 12| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 19| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 19| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 19| else { 317| 19| from>::template op()>( 318| 19| get_member(value, get(to_tie(value))), ctx, it, end); 319| 19| } 320| 19| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 19| } 326| 77| else [[unlikely]] { 327| 77| decode_index_unknown_key(value, ctx, it, end); 328| 77| } 329| 144| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm2EEEDav: 525| 984| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm2ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 984| { 235| 984| static constexpr auto Key = get(reflect::keys); 236| 984| static constexpr auto KeyWithEndQuote = join_v>; 237| 984| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 984| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 977, False: 7] | Branch (239:36): [True: 940, False: 37] ------------------ 240| 940| it += Length; 241| 940| if constexpr (not Opts.null_terminated) { 242| 940| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 940] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 940| } 247| | 248| 940| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 928] ------------------ 249| 12| return; 250| 12| } 251| 928| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 17, False: 911] ------------------ 252| 17| return; 253| 17| } 254| 911| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 897] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 897| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 897| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 897| else { 317| 897| from>::template op()>( 318| 897| get_member(value, get(to_tie(value))), ctx, it, end); 319| 897| } 320| 897| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 897| } 326| 44| else [[unlikely]] { 327| 44| decode_index_unknown_key(value, ctx, it, end); 328| 44| } 329| 984| } _ZN3glz4fromILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 897| { 3086| 897| static constexpr auto num_members = reflect::size; 3087| | 3088| 897| static constexpr auto Opts = opening_handled_off()>(); 3089| 897| if constexpr (!check_opening_handled(Options)) { 3090| | if constexpr (!check_ws_handled(Options)) { 3091| | if (skip_ws(ctx, it, end)) { 3092| | return; 3093| | } 3094| | } 3095| 897| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 23, False: 874] ------------------ 3096| 23| return; 3097| 23| } 3098| 874| if constexpr (not Opts.null_terminated) { 3099| 874| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 874] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 874| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 874| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 874] ------------------ 3107| 0| return; 3108| 0| } 3109| 874| } 3110| 874| const auto ws_start = it; 3111| 897| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 14, False: 883] ------------------ 3112| 14| return; 3113| 14| } 3114| 883| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 883| else { 3189| 883| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 883| if constexpr ((glaze_object_t || reflectable) && 3191| 883| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 883| return bit_array{}; 3193| 883| } 3194| 883| else { 3195| 883| return nullptr; 3196| 883| } 3197| 883| }(); 3198| | 3199| 883| size_t read_count{}; // for partial_read 3200| | 3201| 883| bool first = true; 3202| 6.04k| while (true) { ------------------ | Branch (3202:20): [True: 5.29k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 5.29k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 45, False: 5.25k] ------------------ 3240| 45| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 45| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 45| } 3265| 45| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 45| if constexpr (not Opts.null_terminated) { 3267| 45| if (it == end) { ------------------ | Branch (3267:26): [True: 3, False: 42] ------------------ 3268| 3| ctx.error = error_code::end_reached; 3269| 3| return; 3270| 3| } 3271| 45| } 3272| 42| return; 3273| 45| } 3274| 5.25k| else if (first) { ------------------ | Branch (3274:25): [True: 815, False: 4.43k] ------------------ 3275| 815| first = false; 3276| 815| } 3277| 4.43k| else { 3278| 4.43k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 57, False: 4.38k] ------------------ 3279| 57| return; 3280| 57| } 3281| 4.38k| if constexpr (not Opts.null_terminated) { 3282| 4.38k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 4.38k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 4.38k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| 4.38k| (!Opts.comments)) { 3290| 4.38k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3290:26): [True: 4.11k, False: 270] | Branch (3290:37): [True: 3.97k, False: 141] ------------------ 3291| 3.97k| skip_matching_ws(ws_start, it, ws_size); 3292| 3.97k| } 3293| 4.38k| } 3294| | 3295| 4.38k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 28, False: 4.35k] ------------------ 3296| 28| return; 3297| 28| } 3298| 4.38k| } 3299| | 3300| 5.16k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 5.16k| else if constexpr (reflection_type) { 3364| 5.16k| static_assert(bool(hash_info.type)); 3365| | 3366| 5.16k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 538, False: 4.63k] ------------------ 3367| 538| ctx.error = error_code::expected_quote; 3368| 538| return; 3369| 538| } 3370| 4.63k| ++it; 3371| 4.63k| if constexpr (not Opts.null_terminated) { 3372| 4.63k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 9, False: 4.62k] ------------------ 3373| 9| ctx.error = error_code::unexpected_end; 3374| 9| return; 3375| 9| } 3376| 4.63k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 4.63k| else { 3426| 4.63k| parse_and_invoke(value, ctx, it, end); 3427| 4.63k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 171, False: 4.46k] ------------------ 3428| 171| return; 3429| 4.63k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 5.16k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 12, False: 5.15k] ------------------ 3539| 12| return; 3540| 12| } 3541| 5.16k| } 3542| 883| } 3543| 883| } _ZZN3glz4fromILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 860| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 860| else { 3195| 860| return nullptr; 3196| 860| } 3197| 860| }(); _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm3EEEDav: 525| 822| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm3ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 822| { 235| 822| static constexpr auto Key = get(reflect::keys); 236| 822| static constexpr auto KeyWithEndQuote = join_v>; 237| 822| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 822| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 812, False: 10] | Branch (239:36): [True: 774, False: 38] ------------------ 240| 774| it += Length; 241| 774| if constexpr (not Opts.null_terminated) { 242| 774| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 774] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 774| } 247| | 248| 774| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 762] ------------------ 249| 12| return; 250| 12| } 251| 762| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 19, False: 743] ------------------ 252| 19| return; 253| 19| } 254| 743| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 729] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 729| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 729| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 729| else { 317| 729| from>::template op()>( 318| 729| get_member(value, get(to_tie(value))), ctx, it, end); 319| 729| } 320| 729| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 729| } 326| 48| else [[unlikely]] { 327| 48| decode_index_unknown_key(value, ctx, it, end); 328| 48| } 329| 822| } _ZN3glz4fromILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 729| { 3086| 729| static constexpr auto num_members = reflect::size; 3087| | 3088| 729| static constexpr auto Opts = opening_handled_off()>(); 3089| 729| if constexpr (!check_opening_handled(Options)) { 3090| | if constexpr (!check_ws_handled(Options)) { 3091| | if (skip_ws(ctx, it, end)) { 3092| | return; 3093| | } 3094| | } 3095| 729| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 23, False: 706] ------------------ 3096| 23| return; 3097| 23| } 3098| 706| if constexpr (not Opts.null_terminated) { 3099| 706| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 706] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 706| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 706| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 706] ------------------ 3107| 0| return; 3108| 0| } 3109| 706| } 3110| 706| const auto ws_start = it; 3111| 729| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 12, False: 717] ------------------ 3112| 12| return; 3113| 12| } 3114| 717| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 717| else { 3189| 717| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 717| if constexpr ((glaze_object_t || reflectable) && 3191| 717| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 717| return bit_array{}; 3193| 717| } 3194| 717| else { 3195| 717| return nullptr; 3196| 717| } 3197| 717| }(); 3198| | 3199| 717| size_t read_count{}; // for partial_read 3200| | 3201| 717| bool first = true; 3202| 4.04k| while (true) { ------------------ | Branch (3202:20): [True: 3.44k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 3.44k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 72, False: 3.37k] ------------------ 3240| 72| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 72| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 72| } 3265| 72| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 72| if constexpr (not Opts.null_terminated) { 3267| 72| if (it == end) { ------------------ | Branch (3267:26): [True: 3, False: 69] ------------------ 3268| 3| ctx.error = error_code::end_reached; 3269| 3| return; 3270| 3| } 3271| 72| } 3272| 69| return; 3273| 72| } 3274| 3.37k| else if (first) { ------------------ | Branch (3274:25): [True: 622, False: 2.75k] ------------------ 3275| 622| first = false; 3276| 622| } 3277| 2.75k| else { 3278| 2.75k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 11, False: 2.74k] ------------------ 3279| 11| return; 3280| 11| } 3281| 2.74k| if constexpr (not Opts.null_terminated) { 3282| 2.74k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 2.74k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 2.74k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| 2.74k| (!Opts.comments)) { 3290| 2.74k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (3290:26): [True: 2.66k, False: 75] | Branch (3290:37): [True: 2.53k, False: 128] ------------------ 3291| 2.53k| skip_matching_ws(ws_start, it, ws_size); 3292| 2.53k| } 3293| 2.74k| } 3294| | 3295| 2.74k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 26, False: 2.71k] ------------------ 3296| 26| return; 3297| 26| } 3298| 2.74k| } 3299| | 3300| 3.33k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 3.33k| else if constexpr (reflection_type) { 3364| 3.33k| static_assert(bool(hash_info.type)); 3365| | 3366| 3.33k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 426, False: 2.91k] ------------------ 3367| 426| ctx.error = error_code::expected_quote; 3368| 426| return; 3369| 426| } 3370| 2.91k| ++it; 3371| 2.91k| if constexpr (not Opts.null_terminated) { 3372| 2.91k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 9, False: 2.90k] ------------------ 3373| 9| ctx.error = error_code::unexpected_end; 3374| 9| return; 3375| 9| } 3376| 2.91k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 2.91k| else { 3426| 2.91k| parse_and_invoke(value, ctx, it, end); 3427| 2.91k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 140, False: 2.77k] ------------------ 3428| 140| return; 3429| 2.91k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 3.33k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 10, False: 3.32k] ------------------ 3539| 10| return; 3540| 10| } 3541| 3.33k| } 3542| 717| } 3543| 717| } _ZZN3glz4fromILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 694| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 694| else { 3195| 694| return nullptr; 3196| 694| } 3197| 694| }(); _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm4EEEDav: 525| 9.39k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm4ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 9.39k| { 235| 9.39k| static constexpr auto Key = get(reflect::keys); 236| 9.39k| static constexpr auto KeyWithEndQuote = join_v>; 237| 9.39k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 9.39k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 9.38k, False: 10] | Branch (239:36): [True: 9.36k, False: 23] ------------------ 240| 9.36k| it += Length; 241| 9.36k| if constexpr (not Opts.null_terminated) { 242| 9.36k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 9.36k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 9.36k| } 247| | 248| 9.36k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 14, False: 9.35k] ------------------ 249| 14| return; 250| 14| } 251| 9.35k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 22, False: 9.33k] ------------------ 252| 22| return; 253| 22| } 254| 9.33k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 12, False: 9.31k] ------------------ 255| 12| return; 256| 12| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 9.31k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 9.31k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 9.31k| else { 317| 9.31k| from>::template op()>( 318| 9.31k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 9.31k| } 320| 9.31k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 9.31k| } 326| 33| else [[unlikely]] { 327| 33| decode_index_unknown_key(value, ctx, it, end); 328| 33| } 329| 9.39k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2349| 9.31k| { 2350| 9.31k| constexpr auto Opts = ws_handled_off(); 2351| | if constexpr (!check_ws_handled(Options)) { 2352| | if (skip_ws(ctx, it, end)) { 2353| | return; 2354| | } 2355| | } 2356| | 2357| 9.31k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2357:14): [True: 28, False: 9.29k] ------------------ 2358| 28| return; 2359| 28| } 2360| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2361| | // released at each syntactic close below 2362| 9.29k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2362:14): [True: 0, False: 9.29k] ------------------ 2363| 0| return; 2364| 0| } 2365| | 2366| 9.29k| const auto ws_start = it; 2367| 9.29k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:14): [True: 16, False: 9.27k] ------------------ 2368| 16| return; 2369| 16| } 2370| | 2371| 9.27k| if (*it == ']') { ------------------ | Branch (2371:14): [True: 565, False: 8.70k] ------------------ 2372| 565| --ctx.depth; 2373| 565| ++it; 2374| 565| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2375| 565| value.clear(); 2376| | 2377| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2378| | value.shrink_to_fit(); 2379| | } 2380| 565| } 2381| 565| return; 2382| 565| } 2383| | 2384| 8.70k| const size_t ws_size = size_t(it - ws_start); 2385| | 2386| 8.70k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2386:49): [True: 8.70k, Folded] | Branch (2386:65): [Folded, False: 0] | Branch (2386:90): [Folded, False: 0] ------------------ 2387| 8.70k| if constexpr (not should_append) { 2388| 8.70k| const auto n = value.size(); 2389| | 2390| 8.70k| auto value_it = value.begin(); 2391| | 2392| 61.5k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2392:32): [True: 55.9k, False: 5.52k] ------------------ 2393| 55.9k| parse::op()>(*value_it++, ctx, it, end); 2394| 55.9k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2394:20): [True: 570, False: 55.4k] ------------------ 2395| 570| return; 2396| 55.4k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2396:20): [True: 8, False: 55.4k] ------------------ 2397| 8| return; 2398| 8| } 2399| 55.4k| if (*it == ',') { ------------------ | Branch (2399:20): [True: 52.8k, False: 2.55k] ------------------ 2400| 52.8k| ++it; 2401| | 2402| 52.8k| if constexpr (!Opts.minified && !Opts.comments) { 2403| 52.8k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2403:26): [True: 22.5k, False: 30.3k] | Branch (2403:37): [True: 22.1k, False: 442] ------------------ 2404| 22.1k| skip_matching_ws(ws_start, it, ws_size); 2405| 22.1k| } 2406| 52.8k| } 2407| | 2408| 52.8k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2408:23): [True: 56, False: 52.8k] ------------------ 2409| 56| return; 2410| 56| } 2411| 52.8k| } 2412| 2.55k| else if (*it == ']') { ------------------ | Branch (2412:25): [True: 2.28k, False: 266] ------------------ 2413| 2.28k| --ctx.depth; 2414| 2.28k| ++it; 2415| 2.28k| if constexpr (erasable) { 2416| 2.28k| value.erase(value_it, 2417| 2.28k| value.end()); // use erase rather than resize for non-default constructible elements 2418| | 2419| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2420| | value.shrink_to_fit(); 2421| | } 2422| 2.28k| } 2423| 2.28k| return; 2424| 2.28k| } 2425| 266| else [[unlikely]] { 2426| 266| ctx.error = error_code::expected_bracket; 2427| 266| return; 2428| 266| } 2429| 55.4k| } 2430| 8.70k| } 2431| | 2432| | if constexpr (Opts.partial_read) { 2433| | // partial_read stops early on a success path, so give the level back like the 2434| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2435| | --ctx.depth; 2436| | return; 2437| | } 2438| 8.70k| else { 2439| | // growing 2440| 8.70k| if constexpr (emplace_backable || has_try_emplace_back) { 2441| 163k| while (it < end) { ------------------ | Branch (2441:23): [True: 160k, False: 3.18k] ------------------ 2442| | // Streaming refill point: at start of each iteration, ensure buffer has data 2443| | if constexpr (has_streaming_state) { 2444| | if (ctx.stream.enabled()) { 2445| | const size_t consumed = static_cast(it - ctx.stream.data()); 2446| | const size_t remaining = ctx.stream.size() - consumed; 2447| | // Refill when less than half of buffer remains to ensure space for next element 2448| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2449| | const char* new_it; 2450| | const char* new_end; 2451| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2452| | it = new_it; 2453| | end = new_end; 2454| | if (it >= end && ctx.stream.at_eof()) { 2455| | break; // No more data, exit loop normally 2456| | } 2457| | } 2458| | } 2459| | } 2460| | 2461| | if constexpr (has_try_emplace_back) { 2462| | if (value.try_emplace_back()) 2463| | parse::op()>(value.back(), ctx, it, end); 2464| | else 2465| | ctx.error = error_code::exceeded_static_array_size; 2466| | } 2467| 160k| else { 2468| 160k| parse::op()>(value.emplace_back(), ctx, it, end); 2469| 160k| } 2470| | 2471| 160k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2471:23): [True: 1.40k, False: 158k] ------------------ 2472| 1.40k| return; 2473| | 2474| | // Streaming refill point: after parsing each element, refill if buffer is low 2475| | if constexpr (has_streaming_state) { 2476| | if (ctx.stream.enabled()) { 2477| | const size_t consumed = static_cast(it - ctx.stream.data()); 2478| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2479| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2480| | const char* new_it; 2481| | const char* new_end; 2482| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2483| | it = new_it; 2484| | end = new_end; 2485| | if (it >= end && ctx.stream.at_eof()) { 2486| | ctx.error = error_code::unexpected_end; 2487| | return; 2488| | } 2489| | } 2490| | } 2491| | } 2492| | 2493| 158k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2493:23): [True: 60, False: 158k] ------------------ 2494| 60| return; 2495| 60| } 2496| 158k| if (*it == ',') [[likely]] { ------------------ | Branch (2496:23): [True: 154k, False: 3.96k] ------------------ 2497| 154k| ++it; 2498| | 2499| 154k| if constexpr (!Opts.minified && !Opts.comments) { 2500| 154k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2500:29): [True: 63.3k, False: 91.2k] | Branch (2500:40): [True: 62.8k, False: 477] ------------------ 2501| 62.8k| skip_matching_ws(ws_start, it, ws_size); 2502| 62.8k| } 2503| 154k| } 2504| | 2505| 154k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2505:26): [True: 94, False: 154k] ------------------ 2506| 94| return; 2507| 94| } 2508| 154k| } 2509| 3.96k| else if (*it == ']') { ------------------ | Branch (2509:28): [True: 3.53k, False: 425] ------------------ 2510| 3.53k| --ctx.depth; 2511| 3.53k| ++it; 2512| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2513| | value.shrink_to_fit(); 2514| | } 2515| 3.53k| return; 2516| 3.53k| } 2517| 425| else [[unlikely]] { 2518| 425| ctx.error = error_code::expected_bracket; 2519| 425| return; 2520| 425| } 2521| 158k| } 2522| | 2523| | // A valid array always returns from inside the loop upon reaching ']'. 2524| | // For a null-terminated buffer the loop can only exit here by falling 2525| | // through when `it` reaches the terminator without a closing bracket, 2526| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2527| | // Non-null-terminated buffers surface this through skip_ws/depth 2528| | // tracking (or the streaming refill break), so this guard is limited 2529| | // to the null-terminated case. 2530| | if constexpr (Opts.null_terminated) { 2531| | ctx.error = error_code::unexpected_end; 2532| | } 2533| | } 2534| | else { 2535| | ctx.error = error_code::exceeded_static_array_size; 2536| | } 2537| 8.70k| } 2538| 8.70k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERiTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 495k| { 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| 495k| else { 60| 495k| using V = std::remove_cvref_t; 61| 495k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 495k| end); 63| 495k| } 64| 495k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm5EEEDav: 525| 1.49k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm5ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 1.49k| { 235| 1.49k| static constexpr auto Key = get(reflect::keys); 236| 1.49k| static constexpr auto KeyWithEndQuote = join_v>; 237| 1.49k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 1.49k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 1.48k, False: 12] | Branch (239:36): [True: 1.43k, False: 49] ------------------ 240| 1.43k| it += Length; 241| 1.43k| if constexpr (not Opts.null_terminated) { 242| 1.43k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 1.43k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 1.43k| } 247| | 248| 1.43k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 14, False: 1.41k] ------------------ 249| 14| return; 250| 14| } 251| 1.41k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 20, False: 1.39k] ------------------ 252| 20| return; 253| 20| } 254| 1.39k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 1.38k] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 1.38k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 1.38k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 1.38k| else { 317| 1.38k| from>::template op()>( 318| 1.38k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 1.38k| } 320| 1.38k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 1.38k| } 326| 61| else [[unlikely]] { 327| 61| decode_index_unknown_key(value, ctx, it, end); 328| 61| } 329| 1.49k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 3085| 1.38k| { 3086| 1.38k| static constexpr auto num_members = reflect::size; 3087| | 3088| 1.38k| static constexpr auto Opts = opening_handled_off()>(); 3089| 1.38k| if constexpr (!check_opening_handled(Options)) { 3090| | if constexpr (!check_ws_handled(Options)) { 3091| | if (skip_ws(ctx, it, end)) { 3092| | return; 3093| | } 3094| | } 3095| 1.38k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 24, False: 1.36k] ------------------ 3096| 24| return; 3097| 24| } 3098| 1.36k| if constexpr (not Opts.null_terminated) { 3099| 1.36k| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 1.36k] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 1.36k| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 1.36k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 1.36k] ------------------ 3107| 0| return; 3108| 0| } 3109| 1.36k| } 3110| 1.36k| const auto ws_start = it; 3111| 1.38k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 12, False: 1.37k] ------------------ 3112| 12| return; 3113| 12| } 3114| 1.37k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 1.37k| else { 3189| 1.37k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 1.37k| if constexpr ((glaze_object_t || reflectable) && 3191| 1.37k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 1.37k| return bit_array{}; 3193| 1.37k| } 3194| 1.37k| else { 3195| 1.37k| return nullptr; 3196| 1.37k| } 3197| 1.37k| }(); 3198| | 3199| 1.37k| size_t read_count{}; // for partial_read 3200| | 3201| 1.37k| bool first = true; 3202| 35.3k| while (true) { ------------------ | Branch (3202:20): [True: 34.4k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 34.4k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 83, False: 34.3k] ------------------ 3240| 83| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| | if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| | } 3265| 83| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 83| if constexpr (not Opts.null_terminated) { 3267| 83| if (it == end) { ------------------ | Branch (3267:26): [True: 3, False: 80] ------------------ 3268| 3| ctx.error = error_code::end_reached; 3269| 3| return; 3270| 3| } 3271| 83| } 3272| 80| return; 3273| 83| } 3274| 34.3k| else if (first) { ------------------ | Branch (3274:25): [True: 1.33k, False: 33.0k] ------------------ 3275| 1.33k| first = false; 3276| 1.33k| } 3277| 33.0k| else { 3278| 33.0k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 332, False: 32.6k] ------------------ 3279| 332| return; 3280| 332| } 3281| 32.6k| if constexpr (not Opts.null_terminated) { 3282| 32.6k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 32.6k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 32.6k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| | (!Opts.comments)) { 3290| | if (ws_size && ws_size < size_t(end - it)) { 3291| | skip_matching_ws(ws_start, it, ws_size); 3292| | } 3293| | } 3294| | 3295| 32.6k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 17, False: 32.6k] ------------------ 3296| 17| return; 3297| 17| } 3298| 32.6k| } 3299| | 3300| 34.0k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [Folded, False: 0] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| | else if constexpr (reflection_type) { 3364| | static_assert(bool(hash_info.type)); 3365| | 3366| | if (*it != '"') [[unlikely]] { 3367| | ctx.error = error_code::expected_quote; 3368| | return; 3369| | } 3370| | ++it; 3371| | if constexpr (not Opts.null_terminated) { 3372| | if (it == end) [[unlikely]] { 3373| | ctx.error = error_code::unexpected_end; 3374| | return; 3375| | } 3376| | } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| | else { 3426| | parse_and_invoke(value, ctx, it, end); 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | } 3431| 34.0k| else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| 34.0k| auto reading = [&](auto&& key) { 3435| 34.0k| if constexpr (Opts.partial_read) { 3436| 34.0k| if (auto element = value.find(key); element != value.end()) { 3437| 34.0k| ++read_count; 3438| 34.0k| parse::op()>(element->second, ctx, it, end); 3439| 34.0k| } 3440| 34.0k| else { 3441| 34.0k| skip_value::op(ctx, it, end); 3442| 34.0k| } 3443| 34.0k| } 3444| 34.0k| else { 3445| 34.0k| parse::op()>(value[key], ctx, it, end); 3446| 34.0k| } 3447| 34.0k| }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| 34.0k| using Key = typename T::key_type; 3451| 34.0k| if constexpr (std::is_same_v) { 3452| 34.0k| ctx.scratch.clear(); 3453| 34.0k| parse::op(ctx.scratch, ctx, it, end); 3454| 34.0k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3454:26): [True: 284, False: 33.7k] ------------------ 3455| 284| return; 3456| | 3457| 33.7k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3457:26): [True: 100, False: 33.6k] ------------------ 3458| 100| return; 3459| 100| } 3460| | 3461| 33.6k| reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| 33.6k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3467:26): [True: 500, False: 33.1k] ------------------ 3468| 500| return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| 34.0k| } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 34.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 33, False: 33.9k] ------------------ 3539| 33| return; 3540| 33| } 3541| 34.0k| } 3542| 1.37k| } 3543| 1.37k| } _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: 3189| 1.34k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 1.34k| else { 3195| 1.34k| return nullptr; 3196| 1.34k| } 3197| 1.34k| }(); _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 120k| { 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| 120k| else { 60| 120k| using V = std::remove_cvref_t; 61| 120k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 120k| end); 63| 120k| } 64| 120k| } _ZN3glz4fromILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcSC_S7_TkNS_10is_contextERNS_7contextEQntcl15check_is_paddedTL0__EEEvRT2_OT3_OT0_T1_: 1084| 120k| { 1085| | if constexpr (check_string_as_number(Opts)) { 1086| | auto start = it; 1087| | skip_number(ctx, it, end); 1088| | if (bool(ctx.error)) [[unlikely]] { 1089| | return; 1090| | } 1091| | if (start == it) [[unlikely]] { 1092| | ctx.error = error_code::parse_number_failure; 1093| | return; 1094| | } 1095| | value.append(start, size_t(it - start)); 1096| | } 1097| 120k| else { 1098| 120k| if constexpr (!check_opening_handled(Opts)) { 1099| 120k| if constexpr (!check_ws_handled(Opts)) { 1100| 120k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (1100:23): [True: 97, False: 120k] ------------------ 1101| 97| return; 1102| 97| } 1103| 120k| } 1104| | 1105| 120k| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (1105:20): [True: 36.6k, False: 83.7k] ------------------ 1106| 36.6k| return; 1107| 36.6k| } 1108| 120k| } 1109| | 1110| 120k| if constexpr (not check_raw_string(Opts)) { 1111| 120k| static constexpr auto string_padding_bytes = 8; 1112| | 1113| 120k| if (size_t(end - it) >= 8) { ------------------ | Branch (1113:20): [True: 81.8k, False: 38.5k] ------------------ 1114| 81.8k| auto start = it; 1115| 81.8k| uint64_t ascii_acc{}; 1116| 81.8k| const auto end8 = end - 8; 1117| 8.21M| while (true) { ------------------ | Branch (1117:26): [True: 8.21M, Folded] ------------------ 1118| 8.21M| if (it >= end8) [[unlikely]] { ------------------ | Branch (1118:26): [True: 1.99k, False: 8.21M] ------------------ 1119| 1.99k| break; 1120| 1.99k| } 1121| | 1122| 8.21M| uint64_t chunk; 1123| 8.21M| std::memcpy(&chunk, it, 8); 1124| | if constexpr (std::endian::native == std::endian::big) { 1125| | chunk = std::byteswap(chunk); 1126| | } 1127| 8.21M| ascii_acc |= chunk; 1128| 8.21M| const uint64_t test_chars = has_quote(chunk); 1129| 8.21M| if (test_chars) { ------------------ | Branch (1129:26): [True: 83.7k, False: 8.12M] ------------------ 1130| 83.7k| it += (countr_zero(test_chars) >> 3); 1131| | 1132| 83.7k| auto* prev = it - 1; 1133| 139k| while (*prev == '\\') { ------------------ | Branch (1133:32): [True: 56.2k, False: 83.7k] ------------------ 1134| 56.2k| --prev; 1135| 56.2k| } 1136| 83.7k| if (size_t(it - prev) % 2) { ------------------ | Branch (1136:29): [True: 79.8k, False: 3.94k] ------------------ 1137| 79.8k| goto continue_decode; 1138| 79.8k| } 1139| 3.94k| ++it; // skip the escaped quote 1140| 3.94k| } 1141| 8.12M| else { 1142| 8.12M| it += 8; 1143| 8.12M| } 1144| 8.21M| } 1145| | 1146| 3.48k| while (it[-1] == '\\') [[unlikely]] { ------------------ | Branch (1146:26): [True: 1.49k, False: 1.99k] ------------------ 1147| | // if we ended on an escape character then we need to rewind 1148| | // because we lost our context 1149| 1.49k| --it; 1150| 1.49k| } 1151| | 1152| | // The byte-wise tail keeps feeding the accumulator: it has to cover every byte of 1153| | // the string, or a non-ASCII byte reached here would be waved through unvalidated. 1154| 10.1k| for (; it < end; ++it) { ------------------ | Branch (1154:26): [True: 9.93k, False: 251] ------------------ 1155| 9.93k| ascii_acc |= uint8_t(*it); 1156| 9.93k| if (*it == '"') { ------------------ | Branch (1156:26): [True: 1.83k, False: 8.09k] ------------------ 1157| 1.83k| auto* prev = it - 1; 1158| 2.88k| while (*prev == '\\') { ------------------ | Branch (1158:32): [True: 1.05k, False: 1.83k] ------------------ 1159| 1.05k| --prev; 1160| 1.05k| } 1161| 1.83k| if (size_t(it - prev) % 2) { ------------------ | Branch (1161:29): [True: 1.74k, False: 91] ------------------ 1162| 1.74k| goto continue_decode; 1163| 1.74k| } 1164| 1.83k| } 1165| 9.93k| } 1166| | 1167| 251| ctx.error = error_code::unexpected_end; 1168| 251| return; 1169| | 1170| 81.5k| continue_decode: 1171| | 1172| 81.5k| if (validate_utf8_span(ctx, start, it, ascii_acc)) [[unlikely]] { ------------------ | Branch (1172:23): [True: 507, False: 81.0k] ------------------ 1173| 507| return; 1174| 507| } 1175| | 1176| 81.0k| const auto available_padding = size_t(end - it); 1177| 81.0k| auto n = size_t(it - start); 1178| 81.0k| if (available_padding >= 8) [[likely]] { ------------------ | Branch (1178:23): [True: 78.9k, False: 2.04k] ------------------ 1179| 78.9k| value.resize(n + string_padding_bytes); 1180| | 1181| 78.9k| auto* p = value.data(); 1182| | 1183| 5.78M| while (true) { ------------------ | Branch (1183:29): [True: 5.78M, Folded] ------------------ 1184| 5.78M| if (start >= it) { ------------------ | Branch (1184:29): [True: 70.6k, False: 5.71M] ------------------ 1185| 70.6k| break; 1186| 70.6k| } 1187| | 1188| 5.71M| std::memcpy(p, start, 8); 1189| 5.71M| uint64_t swar; 1190| 5.71M| std::memcpy(&swar, p, 8); 1191| | if constexpr (std::endian::native == std::endian::big) { 1192| | swar = std::byteswap(swar); 1193| | } 1194| | 1195| 5.71M| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 1196| 5.71M| const uint64_t lo7 = swar & lo7_mask; 1197| 5.71M| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 1198| 5.71M| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 1199| 5.71M| uint64_t next = ~((backslash & less_32) | swar); 1200| | 1201| 5.71M| next &= repeat_byte8(0b10000000); 1202| 5.71M| if (next == 0) { ------------------ | Branch (1202:29): [True: 5.66M, False: 46.5k] ------------------ 1203| 5.66M| start += 8; 1204| 5.66M| p += 8; 1205| 5.66M| continue; 1206| 5.66M| } 1207| | 1208| 46.5k| next = countr_zero(next) >> 3; 1209| 46.5k| start += next; 1210| 46.5k| if (start >= it) { ------------------ | Branch (1210:29): [True: 7.96k, False: 38.5k] ------------------ 1211| 7.96k| break; 1212| 7.96k| } 1213| | 1214| 38.5k| if ((*start & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1214:29): [True: 167, False: 38.3k] ------------------ 1215| 167| ctx.error = error_code::syntax_error; 1216| 167| return; 1217| 167| } 1218| 38.3k| ++start; // skip the escape 1219| 38.3k| if (*start == 'u') { ------------------ | Branch (1219:29): [True: 4.58k, False: 33.8k] ------------------ 1220| 4.58k| ++start; 1221| 4.58k| p += next; 1222| 4.58k| const auto mark = start; 1223| 4.58k| const auto offset = handle_unicode_code_point(start, p, end); 1224| 4.58k| if (offset == 0) [[unlikely]] { ------------------ | Branch (1224:32): [True: 200, False: 4.38k] ------------------ 1225| 200| ctx.error = error_code::unicode_escape_conversion_failure; 1226| 200| return; 1227| 200| } 1228| 4.38k| n += offset; 1229| | // escape + u + unicode code points 1230| 4.38k| n -= 2 + uint32_t(start - mark); 1231| 4.38k| } 1232| 33.8k| else { 1233| 33.8k| p += next; 1234| 33.8k| *p = char_unescape_table[uint8_t(*start)]; 1235| 33.8k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1235:32): [True: 52, False: 33.7k] ------------------ 1236| 52| ctx.error = error_code::invalid_escape; 1237| 52| return; 1238| 52| } 1239| 33.7k| ++p; 1240| 33.7k| ++start; 1241| 33.7k| --n; 1242| 33.7k| } 1243| 38.3k| } 1244| | 1245| 78.5k| value.resize(n); 1246| 78.5k| ++it; 1247| 78.5k| } 1248| 2.04k| else { 1249| | // For large inputs this case of running out of buffer is very rare 1250| 2.04k| value.resize(n); 1251| 2.04k| auto* p = value.data(); 1252| | 1253| 2.04k| it = start; 1254| 225k| while (it < end) [[likely]] { ------------------ | Branch (1254:29): [True: 225k, False: 0] ------------------ 1255| 225k| if (*it == '"') { ------------------ | Branch (1255:29): [True: 1.60k, False: 223k] ------------------ 1256| 1.60k| value.resize(size_t(p - value.data())); 1257| 1.60k| ++it; 1258| 1.60k| return; 1259| 1.60k| } 1260| | 1261| 223k| if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1261:29): [True: 185, False: 223k] ------------------ 1262| 185| ctx.error = error_code::syntax_error; 1263| 185| return; 1264| 185| } 1265| | 1266| 223k| *p = *it; 1267| | 1268| 223k| if (*it == '\\') { ------------------ | Branch (1268:29): [True: 12.0k, False: 211k] ------------------ 1269| 12.0k| ++it; // skip the escape 1270| 12.0k| if (*it == 'u') { ------------------ | Branch (1270:32): [True: 2.96k, False: 9.05k] ------------------ 1271| 2.96k| ++it; 1272| 2.96k| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1272:35): [True: 213, False: 2.74k] ------------------ 1273| 213| ctx.error = error_code::unicode_escape_conversion_failure; 1274| 213| return; 1275| 213| } 1276| 2.96k| } 1277| 9.05k| else { 1278| 9.05k| *p = char_unescape_table[uint8_t(*it)]; 1279| 9.05k| if (*p == 0) [[unlikely]] { ------------------ | Branch (1279:35): [True: 50, False: 9.00k] ------------------ 1280| 50| ctx.error = error_code::invalid_escape; 1281| 50| return; 1282| 50| } 1283| 9.00k| ++p; 1284| 9.00k| ++it; 1285| 9.00k| } 1286| 12.0k| } 1287| 211k| else { 1288| 211k| ++it; 1289| 211k| ++p; 1290| 211k| } 1291| 223k| } 1292| | 1293| 0| ctx.error = error_code::unexpected_end; 1294| 0| } 1295| 81.0k| } 1296| 38.5k| else { 1297| | // For short strings 1298| | 1299| 38.5k| std::array buffer{}; 1300| | 1301| 38.5k| auto* p = buffer.data(); 1302| 38.5k| const auto* const utf8_start = it; 1303| | 1304| 41.9k| while (it < end) [[likely]] { ------------------ | Branch (1304:26): [True: 4.86k, False: 37.0k] ------------------ 1305| 4.86k| *p = *it; 1306| 4.86k| if (*it == '"') { ------------------ | Branch (1306:26): [True: 1.29k, False: 3.56k] ------------------ 1307| 1.29k| if (validate_utf8_span(ctx, utf8_start, it)) [[unlikely]] { ------------------ | Branch (1307:29): [True: 309, False: 988] ------------------ 1308| 309| return; 1309| 309| } 1310| 988| const size_t n = size_t(p - buffer.data()); 1311| 988|#if __has_cpp_attribute(assume) >= 202207L 1312| 988| [[assume(n <= sizeof(buffer))]]; 1313| 988|#endif 1314| 988| value.assign(buffer.data(), n); 1315| 988| ++it; 1316| 988| if constexpr (not Opts.null_terminated) { 1317| 988| if (it == end) { ------------------ | Branch (1317:32): [True: 235, False: 753] ------------------ 1318| 235| ctx.error = error_code::end_reached; 1319| 235| return; 1320| 235| } 1321| 988| } 1322| 753| return; 1323| 1.29k| } 1324| 3.56k| else if (*it == '\\') { ------------------ | Branch (1324:31): [True: 326, False: 3.24k] ------------------ 1325| 326| ++it; // skip the escape 1326| 326| if constexpr (not Opts.null_terminated) { 1327| 326| if (it == end) [[unlikely]] { ------------------ | Branch (1327:32): [True: 23, False: 303] ------------------ 1328| 23| ctx.error = error_code::unexpected_end; 1329| 23| return; 1330| 23| } 1331| 326| } 1332| 326| if (*it == 'u') { ------------------ | Branch (1332:29): [True: 200, False: 126] ------------------ 1333| 200| ++it; 1334| 200| if constexpr (not Opts.null_terminated) { 1335| 200| if (it == end) [[unlikely]] { ------------------ | Branch (1335:35): [True: 13, False: 187] ------------------ 1336| 13| ctx.error = error_code::unexpected_end; 1337| 13| return; 1338| 13| } 1339| 200| } 1340| 200| if (!handle_unicode_code_point(it, p, end)) [[unlikely]] { ------------------ | Branch (1340:32): [True: 52, False: 148] ------------------ 1341| 52| ctx.error = error_code::unicode_escape_conversion_failure; 1342| 52| return; 1343| 52| } 1344| 200| } 1345| 126| else { 1346| 126| *p = char_unescape_table[uint8_t(*it)]; 1347| 126| if (*p == 0) [[unlikely]] { ------------------ | Branch (1347:32): [True: 31, False: 95] ------------------ 1348| 31| ctx.error = error_code::invalid_escape; 1349| 31| return; 1350| 31| } 1351| 95| ++p; 1352| 95| ++it; 1353| 95| } 1354| 326| } 1355| 3.24k| else if ((*it & 0b11100000) == 0) [[unlikely]] { ------------------ | Branch (1355:31): [True: 122, False: 3.12k] ------------------ 1356| 122| ctx.error = error_code::syntax_error; 1357| 122| return; 1358| 122| } 1359| 3.12k| else { 1360| 3.12k| ++it; 1361| 3.12k| ++p; 1362| 3.12k| } 1363| 4.86k| } 1364| | 1365| 37.0k| ctx.error = error_code::unexpected_end; 1366| 37.0k| } 1367| | } 1368| | else { 1369| | // raw_string 1370| | auto start = it; 1371| | skip_string_view(ctx, it, end); 1372| | if (bool(ctx.error)) [[unlikely]] 1373| | return; 1374| | 1375| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] { 1376| | return; 1377| | } 1378| | 1379| | value.assign(start, size_t(it - start)); 1380| | ++it; 1381| | } 1382| 120k| } 1383| 120k| } _ZN3glz14parse_ws_colonITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextERPKcS4_EEbRT0_OT1_T2_: 159| 79.7k| { 160| 79.7k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (160:11): [True: 171, False: 79.6k] ------------------ 161| 171| return true; 162| 171| } 163| 79.6k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (163:11): [True: 375, False: 79.2k] ------------------ 164| 375| return true; 165| 375| } 166| 79.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (166:11): [True: 148, False: 79.1k] ------------------ 167| 148| return true; 168| 148| } 169| 79.1k| return false; 170| 79.2k| } _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_: 3434| 33.6k| auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| 33.6k| else { 3445| 33.6k| parse::op()>(value[key], ctx, it, end); 3446| 33.6k| } 3447| 33.6k| }; _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm6EEEDav: 525| 2.43k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm6ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 2.43k| { 235| 2.43k| static constexpr auto Key = get(reflect::keys); 236| 2.43k| static constexpr auto KeyWithEndQuote = join_v>; 237| 2.43k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 2.43k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 2.42k, False: 11] | Branch (239:36): [True: 2.41k, False: 14] ------------------ 240| 2.41k| it += Length; 241| 2.41k| if constexpr (not Opts.null_terminated) { 242| 2.41k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 2.41k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 2.41k| } 247| | 248| 2.41k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 16, False: 2.39k] ------------------ 249| 16| return; 250| 16| } 251| 2.39k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 16, False: 2.37k] ------------------ 252| 16| return; 253| 16| } 254| 2.37k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 11, False: 2.36k] ------------------ 255| 11| return; 256| 11| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 2.36k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 2.36k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 2.36k| else { 317| 2.36k| from>::template op()>( 318| 2.36k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 2.36k| } 320| 2.36k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 2.36k| } 326| 25| else [[unlikely]] { 327| 25| decode_index_unknown_key(value, ctx, it, end); 328| 25| } 329| 2.43k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 5098| 2.36k| { 5099| 2.36k| constexpr auto Opts = ws_handled_off(); 5100| | if constexpr (!check_ws_handled(Options)) { 5101| | if (skip_ws(ctx, it, end)) { 5102| | return; 5103| | } 5104| | } 5105| | 5106| 2.36k| if (*it == 'n') { ------------------ | Branch (5106:14): [True: 1.13k, False: 1.23k] ------------------ 5107| 1.13k| ++it; 5108| 1.13k| if constexpr (not Opts.null_terminated) { 5109| 1.13k| if (it == end) [[unlikely]] { ------------------ | Branch (5109:20): [True: 3, False: 1.12k] ------------------ 5110| 3| ctx.error = error_code::unexpected_end; 5111| 3| return; 5112| 3| } 5113| 1.13k| } 5114| 1.12k| match<"ull", Opts>(ctx, it, end); 5115| 1.13k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (5115:17): [True: 44, False: 1.08k] ------------------ 5116| 44| return; 5117| 1.08k| if constexpr (requires { value.reset(); }) { 5118| 1.08k| value.reset(); 5119| 1.08k| } 5120| 1.08k| } 5121| 1.23k| else { 5122| 1.23k| if constexpr (nullable_value_t) { 5123| 1.23k| if (not value.has_value()) { ------------------ | Branch (5123:20): [True: 793, False: 444] ------------------ 5124| | if constexpr (constructible) { 5125| | value = meta_construct_v(); 5126| | } 5127| 793| else if constexpr (requires { value.emplace(); }) { 5128| 793| value.emplace(); 5129| | } 5130| | else { 5131| | static_assert(false_v, 5132| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 5133| | "create a custom glz::from specialization"); 5134| | } 5135| 793| } 5136| 1.23k| parse::op(value.value(), ctx, it, end); 5137| | } 5138| | else { 5139| | if (!value) { 5140| | if (!nullable_emplace(value, ctx)) { 5141| | return; 5142| | } 5143| | } 5144| | parse::op(*value, ctx, it, end); 5145| | } 5146| 1.23k| } 5147| 2.36k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 27.2k| { 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| 27.2k| else { 60| 27.2k| using V = std::remove_cvref_t; 61| 27.2k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 27.2k| end); 63| 27.2k| } 64| 27.2k| } _ZN3glz4fromILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERPKcRdTkNS_10is_contextERNS_7contextES5_EEvOT1_OT2_OT0_T3_: 808| 27.2k| { 809| | if constexpr (check_quoted_num(Opts)) { 810| | if (skip_ws(ctx, it, end)) { 811| | return; 812| | } 813| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 814| | return; 815| | } 816| | } 817| | 818| 27.2k| if constexpr (!check_ws_handled(Opts)) { 819| 27.2k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (819:17): [True: 33, False: 27.2k] ------------------ 820| 33| return; 821| 33| } 822| 27.2k| } 823| | 824| 27.2k| using V = std::decay_t; 825| | if constexpr (int_t) { 826| | static_assert(sizeof(*it) == sizeof(char)); 827| | 828| | if constexpr (Opts.null_terminated) { 829| | if (not glz::atoi(value, it)) [[unlikely]] { 830| | ctx.error = error_code::parse_number_failure; 831| | return; 832| | } 833| | } 834| | else { 835| | if (not glz::atoi(value, it, end)) [[unlikely]] { 836| | ctx.error = error_code::parse_number_failure; 837| | return; 838| | } 839| | } 840| | } 841| 27.2k| else { 842| |// float128_t requires std::from_chars for floating-point, unavailable on older Apple platforms (iOS < 16.3) 843| 27.2k|#if !defined(_LIBCPP_VERSION) || defined(_LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT) 844| | if constexpr (is_float128) { 845| | auto [ptr, ec] = std::from_chars(it, end, value); 846| | if (ec != std::errc()) { 847| | ctx.error = error_code::parse_number_failure; 848| | return; 849| | } 850| | it = ptr; 851| | } 852| | else 853| |#endif 854| 27.2k| { 855| | if constexpr (std::is_volatile_v>) { 856| | // Hardware may interact with value changes, so we parse into a temporary and assign in one 857| | // place 858| | V temp; 859| | if constexpr (is_size_optimized(Opts)) { 860| | auto [ptr, ec] = simple_float::from_chars(it, end, temp); 861| | if (ec != std::errc{}) [[unlikely]] { 862| | ctx.error = error_code::parse_number_failure; 863| | return; 864| | } 865| | it = ptr; 866| | } 867| | else { 868| | auto [ptr, ec] = glz::from_chars(it, end, temp); 869| | if (ec != std::errc()) [[unlikely]] { 870| | ctx.error = error_code::parse_number_failure; 871| | return; 872| | } 873| | it = ptr; 874| | } 875| | value = temp; 876| | } 877| 27.2k| else { 878| | if constexpr (is_size_optimized(Opts)) { 879| | auto [ptr, ec] = simple_float::from_chars(it, end, value); 880| | if (ec != std::errc{}) [[unlikely]] { 881| | ctx.error = error_code::parse_number_failure; 882| | return; 883| | } 884| | it = ptr; 885| | } 886| 27.2k| else { 887| 27.2k| auto [ptr, ec] = glz::from_chars(it, end, value); 888| 27.2k| if (ec != std::errc()) [[unlikely]] { ------------------ | Branch (888:26): [True: 23.0k, False: 4.19k] ------------------ 889| 23.0k| ctx.error = error_code::parse_number_failure; 890| 23.0k| return; 891| 23.0k| } 892| 4.19k| it = ptr; 893| 4.19k| } 894| 27.2k| } 895| 27.2k| } 896| 27.2k| } 897| | 898| | if constexpr (check_quoted_num(Opts)) { 899| | if constexpr (not Opts.null_terminated) { 900| | if (it == end) [[unlikely]] { 901| | ctx.error = error_code::unexpected_end; 902| | return; 903| | } 904| | } 905| | if (match<'"'>(ctx, it)) { 906| | return; 907| | } 908| | if constexpr (not Opts.null_terminated) { 909| | if (it == end) { 910| | ctx.error = error_code::end_reached; 911| | return; 912| | } 913| | } 914| | } 915| 27.2k| else { 916| 27.2k| if constexpr (not Opts.null_terminated) { 917| 27.2k| if (it == end) { ------------------ | Branch (917:20): [True: 1.55k, False: 25.7k] ------------------ 918| 1.55k| ctx.error = error_code::end_reached; 919| 1.55k| return; 920| 1.55k| } 921| 27.2k| } 922| 27.2k| } 923| 27.2k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm7EEEDav: 525| 9.14k| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm7ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 9.14k| { 235| 9.14k| static constexpr auto Key = get(reflect::keys); 236| 9.14k| static constexpr auto KeyWithEndQuote = join_v>; 237| 9.14k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 9.14k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 9.13k, False: 11] | Branch (239:36): [True: 8.94k, False: 189] ------------------ 240| 8.94k| it += Length; 241| 8.94k| if constexpr (not Opts.null_terminated) { 242| 8.94k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 8.94k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 8.94k| } 247| | 248| 8.94k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 14, False: 8.93k] ------------------ 249| 14| return; 250| 14| } 251| 8.93k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 21, False: 8.90k] ------------------ 252| 21| return; 253| 21| } 254| 8.90k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 10, False: 8.89k] ------------------ 255| 10| return; 256| 10| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 8.89k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 8.89k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 8.89k| else { 317| 8.89k| from>::template op()>( 318| 8.89k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 8.89k| } 320| 8.89k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 8.89k| } 326| 200| else [[unlikely]] { 327| 200| decode_index_unknown_key(value, ctx, it, end); 328| 200| } 329| 9.14k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4093| 8.89k| { 4094| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4095| | read_adjacent(value, ctx, it, end); 4096| | } 4097| 8.89k| else { 4098| 8.89k| read_deduced(value, ctx, it, end); 4099| 8.89k| } 4100| 8.89k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4104| 8.89k| { 4105| 8.89k| constexpr auto Opts = ws_handled_off(); 4106| 8.89k| if constexpr (variant_is_auto_deducible()) { 4107| | if constexpr (not check_ws_handled(Options)) { 4108| | if (skip_ws(ctx, it, end)) { 4109| | return; 4110| | } 4111| | } 4112| | 4113| 8.89k| switch (*it) { 4114| 5| case '\0': ------------------ | Branch (4114:13): [True: 5, False: 8.89k] ------------------ 4115| 5| ctx.error = error_code::unexpected_end; 4116| 5| return; 4117| 5.39k| case '{': { ------------------ | Branch (4117:13): [True: 5.39k, False: 3.50k] ------------------ 4118| | // This branch consumes the brace itself and hands the object to a reader with 4119| | // `opening_handled`, which therefore does not count the level -- but does release it at 4120| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4121| | // the reader below. 4122| 5.39k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4122:20): [True: 0, False: 5.39k] ------------------ 4123| 0| return; 4124| 0| } 4125| | 4126| 5.39k| ++it; 4127| 5.39k| if constexpr (not Opts.null_terminated) { 4128| 5.39k| if (it == end) [[unlikely]] { ------------------ | Branch (4128:23): [True: 5, False: 5.39k] ------------------ 4129| 5| ctx.error = error_code::unexpected_end; 4130| 5| return; 4131| 5| } 4132| 5.39k| } 4133| 5.39k| using type_counts = variant_type_count; 4134| 5.39k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4135| | if constexpr (n_object_candidates < 1) { 4136| | ctx.error = error_code::no_matching_variant_type; 4137| | return; 4138| | } 4139| 5.39k| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4140| 5.39k| constexpr auto first_idx = variant_first_object_candidate_v; 4141| 5.39k| using V = std::variant_alternative_t; 4142| 5.39k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4142:23): [True: 1.62k, False: 3.77k] ------------------ 4143| 5.39k| parse::op()>(std::get(value), ctx, it, end); 4144| 5.39k| return; 4145| | } 4146| | else { 4147| | auto possible_types = bit_array>{}.flip(); 4148| | static constexpr auto& deduction_bits = variant_deduction_bits; 4149| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4150| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4151| | 4152| | // Track if we've encountered a tag and what value it had 4153| | std::optional tag_specified_index{}; 4154| | 4155| | if (skip_ws(ctx, it, end)) { 4156| | return; 4157| | } 4158| | auto start = it; 4159| | bool first_key = true; 4160| | // Parse bifurcation for tagged variants: 4161| | // 4162| | // Without this optimization, tagged variant parsing always uses two passes: 4163| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4164| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4165| | // 4166| | // When the tag is the first key, the second pass redundantly re-reads every 4167| | // field that follows it. This lambda avoids that: if the tag was the first key, 4168| | // it advances past the trailing comma so the object parser picks up at the 4169| | // second field. If the tag was found later, it falls back to the full re-parse. 4170| | // 4171| | // One exception: if the tag name is also a field on the resolved struct 4172| | // (contains_tag), we must re-parse regardless so the value is stored in 4173| | // the struct field. This override is applied inside each std::visit lambda. 4174| | auto position_after_tag = [&] { 4175| | if (first_key) { 4176| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4177| | } 4178| | else { 4179| | it = start; // tag was not the first key, re-parse from the beginning 4180| | } 4181| | }; 4182| | while (*it != '}') { 4183| | if (it != start) { 4184| | first_key = false; 4185| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4186| | return; 4187| | } 4188| | } 4189| | 4190| | if (skip_ws(ctx, it, end)) { 4191| | return; 4192| | } 4193| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4194| | return; 4195| | } 4196| | 4197| | auto* key_start = it; 4198| | skip_string_view(ctx, it, end); 4199| | if (bool(ctx.error)) [[unlikely]] 4200| | return; 4201| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4202| | return; 4203| | const sv key = {key_start, size_t(it - key_start)}; 4204| | 4205| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4206| | return; 4207| | } 4208| | 4209| | if constexpr (deduction_key_count > 0) { 4210| | // We first check if a tag is defined and see if the key matches the tag 4211| | if constexpr (not tag_v.empty()) { 4212| | if (key == tag_v) { 4213| | if (parse_ws_colon(ctx, it, end)) { 4214| | return; 4215| | } 4216| | 4217| | using id_type = std::decay_t[0])>; 4218| | 4219| | std::conditional_t, id_type, sv> type_id{}; 4220| | if constexpr (std::integral) { 4221| | from::template op()>(type_id, ctx, it, end); 4222| | } 4223| | else { 4224| | from::template op()>(type_id, ctx, it, end); 4225| | } 4226| | if (bool(ctx.error)) [[unlikely]] 4227| | return; 4228| | if (skip_ws(ctx, it, end)) { 4229| | return; 4230| | } 4231| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4232| | ctx.error = error_code::syntax_error; 4233| | return; 4234| | } 4235| | 4236| | size_t type_index; 4237| | if constexpr (std::integral) { 4238| | type_index = variant_id_to_index::op(type_id); 4239| | } 4240| | else { 4241| | type_index = variant_id_to_index::op( 4242| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4243| | } 4244| | if (type_index < ids_v.size()) [[likely]] { 4245| | // Check if the deduced types include the tag-specified type 4246| | // If not, the tag doesn't match the fields 4247| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4248| | // is happening. At this point, possible_types has been narrowed by field deduction. 4249| | // Check if the tag-specified type is still possible 4250| | const bool type_is_possible = possible_types[type_index]; 4251| | if (!type_is_possible) { 4252| | // Tag specifies a type that doesn't match the fields seen so far 4253| | ctx.error = error_code::no_matching_variant_type; 4254| | return; 4255| | } 4256| | 4257| | position_after_tag(); 4258| | tag_specified_index = type_index; // Store the tag-specified type 4259| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4260| | std::visit( 4261| | [&](auto&& v) { 4262| | using V = std::decay_t; 4263| | constexpr bool is_object = 4264| | (glaze_object_t || reflectable) && not custom_read; 4265| | if constexpr (variant_unit_alternative) { 4266| | // A unit alternative carries no data; its object holds only the 4267| | // discriminator. Consume that body through an empty reflected object so 4268| | // unknown-key policy and terminator handling match every other alternative. 4269| | detail::variant_unit_body unit_body{}; 4270| | from::template op(), 4271| | tag_literal>(unit_body, 4272| | ctx, it, end); 4273| | } 4274| | else if constexpr (is_object) { 4275| | if constexpr (contains_tag()) { 4276| | it = start; // tag is a struct field, must re-parse 4277| | } 4278| | from::template op(), tag_literal>(v, ctx, it, 4279| | end); 4280| | } 4281| | else if constexpr (is_memory_object) { 4282| | if (!v) { 4283| | if constexpr (is_specialization_v) { 4284| | if constexpr (requires { v.emplace(); }) { 4285| | v.emplace(); 4286| | } 4287| | else { 4288| | v = typename V::value_type{}; 4289| | } 4290| | } 4291| | else if constexpr (is_specialization_v) 4292| | v = std::make_unique(); 4293| | else if constexpr (is_specialization_v) 4294| | v = std::make_shared(); 4295| | else if constexpr (constructible) { 4296| | v = meta_construct_v(); 4297| | } 4298| | else if constexpr (std::is_pointer_v && 4299| | can_allocate_raw_pointer>) { 4301| | if (!try_allocate_raw_pointer(v, ctx)) { 4302| | return; 4303| | } 4304| | } 4305| | else { 4306| | ctx.error = error_code::invalid_nullable_read; 4307| | return; 4308| | // Cannot read into unset nullable that is not std::optional, 4309| | // std::unique_ptr, or std::shared_ptr 4310| | } 4311| | } 4312| | if constexpr (contains_tag, tag_literal>()) { 4313| | it = start; // tag is a struct field, must re-parse 4314| | } 4315| | from>::template op(), tag_literal>( 4316| | *v, ctx, it, end); 4317| | } 4318| | else if constexpr (custom_read) { 4319| | // Custom handlers parse the remaining body themselves and do not 4320| | // accept the tag template parameter; the tag was already consumed. 4321| | // This only works when the tag was the first key. If it came later, 4322| | // we were reset to the object start and the custom handler would 4323| | // absorb the tag, so error rather than corrupt the value. 4324| | if (it == start) { 4325| | ctx.error = error_code::feature_not_supported; 4326| | ctx.custom_error_message = 4327| | "the tag must be the first key for a custom variant alternative"; 4328| | return; 4329| | } 4330| | from::template op()>(v, ctx, it, end); 4331| | } 4332| | }, 4333| | value); 4334| | 4335| | return; // we've decoded our target type 4336| | } 4337| | else [[unlikely]] { 4338| | // Check if we have a default type (ids array shorter than variant) 4339| | constexpr auto ids_size = ids_v.size(); 4340| | constexpr auto variant_size = std::variant_size_v; 4341| | if constexpr (ids_size < variant_size) { 4342| | // Use the first unlabeled type as the default 4343| | const auto default_type_index = ids_size; 4344| | 4345| | position_after_tag(); 4346| | tag_specified_index = default_type_index; // Store the default type index 4347| | if (value.index() != default_type_index) 4348| | emplace_runtime_variant(value, default_type_index); 4349| | std::visit( 4350| | [&](auto&& v) { 4351| | using V = std::decay_t; 4352| | constexpr bool is_object = 4353| | (glaze_object_t || reflectable) && not custom_read; 4354| | if constexpr (variant_unit_alternative) { 4355| | // A unit alternative carries no data; its object holds only the 4356| | // discriminator. Consume that body through an empty reflected object so 4357| | // unknown-key policy and terminator handling match every other 4358| | // alternative. 4359| | detail::variant_unit_body unit_body{}; 4360| | from::template op(), 4361| | tag_literal>( 4362| | unit_body, ctx, it, end); 4363| | } 4364| | else if constexpr (is_object) { 4365| | if constexpr (contains_tag()) { 4366| | it = start; // tag is a struct field, must re-parse 4367| | } 4368| | from::template op()>(v, ctx, it, end); 4369| | } 4370| | else if constexpr (is_memory_object) { 4371| | if (!v) { 4372| | if constexpr (is_specialization_v) { 4373| | if constexpr (requires { v.emplace(); }) { 4374| | v.emplace(); 4375| | } 4376| | else { 4377| | v = typename V::value_type{}; 4378| | } 4379| | } 4380| | else if constexpr (is_specialization_v) 4381| | v = std::make_unique(); 4382| | else if constexpr (is_specialization_v) 4383| | v = std::make_shared(); 4384| | else if constexpr (constructible) { 4385| | v = meta_construct_v(); 4386| | } 4387| | else if constexpr (std::is_pointer_v && 4388| | can_allocate_raw_pointer< 4389| | Opts, std::decay_t>) { 4390| | if (!try_allocate_raw_pointer(v, ctx)) { 4391| | return; 4392| | } 4393| | } 4394| | else { 4395| | ctx.error = error_code::invalid_nullable_read; 4396| | return; 4397| | } 4398| | } 4399| | if constexpr (contains_tag, tag_literal>()) { 4400| | it = start; // tag is a struct field, must re-parse 4401| | } 4402| | from>::template op()>(*v, ctx, 4403| | it, end); 4404| | } 4405| | else if constexpr (custom_read) { 4406| | // Custom handlers parse the remaining body themselves; this only 4407| | // works when the tag was the first key (see above). If it came 4408| | // later we were reset to the object start, so error rather than 4409| | // let the custom handler absorb the tag. 4410| | if (it == start) { 4411| | ctx.error = error_code::feature_not_supported; 4412| | ctx.custom_error_message = 4413| | "the tag must be the first key for a custom variant alternative"; 4414| | return; 4415| | } 4416| | from::template op()>(v, ctx, it, end); 4417| | } 4418| | }, 4419| | value); 4420| | 4421| | return; 4422| | } 4423| | else { 4424| | ctx.error = error_code::no_matching_variant_type; 4425| | ctx.custom_error_message = variant_ids_string_v; 4426| | return; 4427| | } 4428| | } 4429| | } 4430| | } 4431| | 4432| | // Inline decode_hash lookup for variant deduction 4433| | using deduction_keys_t = keys_wrapper>; 4434| | constexpr auto& DeductionHashInfo = hash_info; 4435| | const auto deduction_index = 4436| | decode_hash_with_size::op( 4437| | key.data(), key.data() + key.size(), key.size()); 4438| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4439| | [[likely]] { 4440| | possible_types &= deduction_bits[deduction_index]; 4441| | } 4442| | else if constexpr (Opts.error_on_unknown_keys) { 4443| | ctx.error = error_code::unknown_key; 4444| | return; 4445| | } 4446| | } 4447| | else if constexpr (not tag_v.empty()) { 4448| | // empty object case for variant, if there are no normal elements 4449| | if (key == tag_v) { 4450| | if (parse_ws_colon(ctx, it, end)) { 4451| | return; 4452| | } 4453| | 4454| | std::string_view type_id{}; 4455| | parse::op()>(type_id, ctx, it, end); 4456| | if (bool(ctx.error)) [[unlikely]] 4457| | return; 4458| | if (skip_ws(ctx, it, end)) { 4459| | return; 4460| | } 4461| | 4462| | const auto type_index = variant_id_to_index::op( 4463| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4464| | if (type_index < ids_v.size()) [[likely]] { 4465| | position_after_tag(); 4466| | tag_specified_index = type_index; // Store the tag-specified type 4467| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4468| | } 4469| | else { 4470| | // Check if we have a default type (ids array shorter than variant) 4471| | constexpr auto ids_size = ids_v.size(); 4472| | constexpr auto variant_size = std::variant_size_v; 4473| | if constexpr (ids_size < variant_size) { 4474| | // Use the first unlabeled type as the default 4475| | position_after_tag(); 4476| | const auto default_index = ids_size; 4477| | tag_specified_index = default_index; // Store the default type index 4478| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4479| | } 4480| | else { 4481| | ctx.error = error_code::no_matching_variant_type; 4482| | ctx.custom_error_message = variant_ids_string_v; 4483| | return; 4484| | } 4485| | } 4486| | // Parse the type (handles tag skipping and unknown keys) 4487| | std::visit( 4488| | [&](auto&& v) { 4489| | using V = std::decay_t; 4490| | if constexpr (custom_read) { 4491| | // Custom handlers parse the remaining object body themselves and do not 4492| | // accept the tag template parameter that reflected objects use to skip an 4493| | // interior tag key. That only works when the tag is the first key (it was 4494| | // just consumed). If the tag came after other keys, position_after_tag() 4495| | // reset us to the object start and the custom handler would absorb the tag 4496| | // into its value, so error here rather than corrupt the result. 4497| | if (it == start) { 4498| | ctx.error = error_code::feature_not_supported; 4499| | ctx.custom_error_message = 4500| | "the tag must be the first key for a custom variant alternative"; 4501| | return; 4502| | } 4503| | from::template op()>(v, ctx, it, end); 4504| | } 4505| | else { 4506| | if constexpr (contains_tag()) { 4507| | it = start; // tag is a struct field, must re-parse 4508| | } 4509| | from::template op(), tag_literal>(v, ctx, it, end); 4510| | } 4511| | }, 4512| | value); 4513| | return; 4514| | } 4515| | else if constexpr (Opts.error_on_unknown_keys) { 4516| | ctx.error = error_code::unknown_key; 4517| | return; 4518| | } 4519| | else { 4520| | // Skip unknown key's value (non-tag key in empty variant) 4521| | if (parse_ws_colon(ctx, it, end)) { 4522| | return; 4523| | } 4524| | skip_value::op(ctx, it, end); 4525| | if (bool(ctx.error)) [[unlikely]] 4526| | return; 4527| | if (skip_ws(ctx, it, end)) { 4528| | return; 4529| | } 4530| | continue; // Continue loop to find the tag 4531| | } 4532| | } 4533| | else if constexpr (Opts.error_on_unknown_keys) { 4534| | ctx.error = error_code::unknown_key; 4535| | return; 4536| | } 4537| | 4538| | auto matching_types = possible_types.popcount(); 4539| | if (matching_types == 0) { 4540| | ctx.error = error_code::no_matching_variant_type; 4541| | return; 4542| | } 4543| | // Only short-circuit for variants without tags 4544| | else if constexpr (tag_v.empty()) { 4545| | if (matching_types == 1) { 4546| | it = start; 4547| | const auto type_index = possible_types.countr_zero(); 4548| | 4549| | if (value.index() != static_cast(type_index)) 4550| | emplace_runtime_variant(value, type_index); 4551| | std::visit( 4552| | [&](auto&& v) { 4553| | using V = std::decay_t; 4554| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4555| | if constexpr (variant_unit_alternative) { 4556| | // A unit alternative carries no data; its object holds only the discriminator. 4557| | // Consume that body through an empty reflected object so unknown-key policy and 4558| | // terminator handling match every other alternative. 4559| | detail::variant_unit_body unit_body{}; 4560| | from::template op(), 4561| | tag_literal>(unit_body, ctx, it, 4562| | end); 4563| | } 4564| | else if constexpr (is_object) { 4565| | from::template op(), tag_literal>(v, ctx, it, end); 4566| | } 4567| | else if constexpr (is_memory_object) { 4568| | if (!v) { 4569| | if constexpr (is_specialization_v) { 4570| | if constexpr (requires { v.emplace(); }) { 4571| | v.emplace(); 4572| | } 4573| | else { 4574| | v = typename V::value_type{}; 4575| | } 4576| | } 4577| | else if constexpr (is_specialization_v) 4578| | v = std::make_unique(); 4579| | else if constexpr (is_specialization_v) 4580| | v = std::make_shared(); 4581| | else if constexpr (constructible) { 4582| | v = meta_construct_v(); 4583| | } 4584| | else if constexpr (std::is_pointer_v && 4585| | can_allocate_raw_pointer>) { 4586| | if (!try_allocate_raw_pointer(v, ctx)) { 4587| | return; 4588| | } 4589| | } 4590| | else { 4591| | ctx.error = error_code::invalid_nullable_read; 4592| | return; 4593| | // Cannot read into unset nullable that is not std::optional, 4594| | // std::unique_ptr, or std::shared_ptr 4595| | } 4596| | } 4597| | from>::template op(), tag_literal>( 4598| | *v, ctx, it, end); 4599| | } 4600| | else if constexpr (custom_read) { 4601| | // Custom handlers parse the remaining body themselves. 4602| | from::template op()>(v, ctx, it, end); 4603| | } 4604| | }, 4605| | value); 4606| | 4607| | return; // we've decoded our target type 4608| | } 4609| | } 4610| | // For tagged variants, continue processing to validate tags 4611| | if (parse_ws_colon(ctx, it, end)) { 4612| | return; 4613| | } 4614| | 4615| | skip_value::op(ctx, it, end); 4616| | if (bool(ctx.error)) [[unlikely]] 4617| | return; 4618| | if (skip_ws(ctx, it, end)) { 4619| | return; 4620| | } 4621| | } 4622| | // Only apply ambiguous variant resolution if we have multiple object types 4623| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4624| | // After parsing all keys, check if we have multiple matching types 4625| | // If so, choose the one with the fewest fields 4626| | auto final_matching = possible_types.popcount(); 4627| | if (final_matching == 0) { 4628| | ctx.error = error_code::no_matching_variant_type; 4629| | } 4630| | else if (final_matching == 1) { 4631| | // Single type remains after field deduction 4632| | const auto type_index = possible_types.countr_zero(); 4633| | 4634| | // Validate against tag if one was specified 4635| | if (tag_specified_index.has_value() && 4636| | tag_specified_index.value() != static_cast(type_index)) { 4637| | ctx.error = error_code::no_matching_variant_type; 4638| | return; 4639| | } 4640| | 4641| | it = start; 4642| | if (value.index() != static_cast(type_index)) 4643| | emplace_runtime_variant(value, type_index); 4644| | std::visit( 4645| | [&](auto&& v) { 4646| | using V = std::decay_t; 4647| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4648| | if constexpr (variant_unit_alternative) { 4649| | // A unit alternative carries no data; its object holds only the discriminator. 4650| | // Consume that body through an empty reflected object so unknown-key policy and 4651| | // terminator handling match every other alternative. 4652| | detail::variant_unit_body unit_body{}; 4653| | from::template op(), 4654| | tag_literal>(unit_body, ctx, it, 4655| | end); 4656| | } 4657| | else if constexpr (is_object) { 4658| | from::template op(), tag_literal>(v, ctx, it, end); 4659| | } 4660| | else if constexpr (is_memory_object) { 4661| | if (!v) { 4662| | if constexpr (is_specialization_v) { 4663| | if constexpr (requires { v.emplace(); }) { 4664| | v.emplace(); 4665| | } 4666| | else { 4667| | v = typename V::value_type{}; 4668| | } 4669| | } 4670| | else if constexpr (is_specialization_v) 4671| | v = std::make_unique(); 4672| | else if constexpr (is_specialization_v) 4673| | v = std::make_shared(); 4674| | else if constexpr (constructible) { 4675| | v = meta_construct_v(); 4676| | } 4677| | else if constexpr (std::is_pointer_v && 4678| | can_allocate_raw_pointer>) { 4679| | if (!try_allocate_raw_pointer(v, ctx)) { 4680| | return; 4681| | } 4682| | } 4683| | else { 4684| | ctx.error = error_code::invalid_nullable_read; 4685| | return; 4686| | } 4687| | } 4688| | from>::template op(), tag_literal>(*v, ctx, 4689| | it, end); 4690| | } 4691| | else if constexpr (custom_read) { 4692| | // Custom handlers parse the remaining body themselves. 4693| | from::template op()>(v, ctx, it, end); 4694| | } 4695| | }, 4696| | value); 4697| | } 4698| | else if (final_matching > 1) { 4699| | constexpr auto N = std::variant_size_v; 4700| | 4701| | // Compile-time array of field counts for each variant type 4702| | constexpr auto field_counts = [](std::index_sequence) { 4703| | return std::array { 4704| | ([]() -> size_t { 4705| | using V = std::decay_t>; 4706| | if constexpr (glaze_object_t || reflectable) { 4707| | return reflect::size; 4708| | } 4709| | else if constexpr (is_memory_object) { 4710| | using X = memory_type; 4711| | if constexpr (glaze_object_t || reflectable) { 4712| | return reflect::size; 4713| | } 4714| | else { 4715| | return (std::numeric_limits::max)(); 4716| | } 4717| | } 4718| | else { 4719| | return (std::numeric_limits::max)(); 4720| | } 4721| | }.template operator()())... 4722| | }; 4723| | }(std::make_index_sequence{}); 4724| | 4725| | // Find the type with minimum field count among the possible types 4726| | size_t min_fields = (std::numeric_limits::max)(); 4727| | size_t chosen_index = N; // Invalid index initially 4728| | 4729| | for (size_t i = 0; i < N; ++i) { 4730| | if (possible_types[i] && field_counts[i] < min_fields) { 4731| | min_fields = field_counts[i]; 4732| | chosen_index = i; 4733| | } 4734| | } 4735| | 4736| | if (chosen_index < N) { 4737| | // Validate against tag if one was specified 4738| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4739| | ctx.error = error_code::no_matching_variant_type; 4740| | return; 4741| | } 4742| | 4743| | it = start; 4744| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4745| | std::visit( 4746| | [&](auto&& v) { 4747| | using V = std::decay_t; 4748| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4749| | if constexpr (variant_unit_alternative) { 4750| | // A unit alternative carries no data; its object holds only the discriminator. 4751| | // Consume that body through an empty reflected object so unknown-key policy and 4752| | // terminator handling match every other alternative. 4753| | detail::variant_unit_body unit_body{}; 4754| | from::template op(), 4755| | tag_literal>(unit_body, ctx, it, 4756| | end); 4757| | } 4758| | else if constexpr (is_object) { 4759| | from::template op(), tag_literal>(v, ctx, it, end); 4760| | } 4761| | else if constexpr (is_memory_object) { 4762| | if (!v) { 4763| | if constexpr (is_specialization_v) { 4764| | if constexpr (requires { v.emplace(); }) { 4765| | v.emplace(); 4766| | } 4767| | else { 4768| | v = typename V::value_type{}; 4769| | } 4770| | } 4771| | else if constexpr (is_specialization_v) 4772| | v = std::make_unique(); 4773| | else if constexpr (is_specialization_v) 4774| | v = std::make_shared(); 4775| | else if constexpr (constructible) { 4776| | v = meta_construct_v(); 4777| | } 4778| | else if constexpr (std::is_pointer_v && 4779| | can_allocate_raw_pointer>) { 4780| | if (!try_allocate_raw_pointer(v, ctx)) { 4781| | return; 4782| | } 4783| | } 4784| | else { 4785| | ctx.error = error_code::invalid_nullable_read; 4786| | return; 4787| | } 4788| | } 4789| | from>::template op(), tag_literal>( 4790| | *v, ctx, it, end); 4791| | } 4792| | else if constexpr (custom_read) { 4793| | // Custom handlers parse the remaining body themselves. 4794| | from::template op()>(v, ctx, it, end); 4795| | } 4796| | }, 4797| | value); 4798| | } 4799| | else { 4800| | ctx.error = error_code::no_matching_variant_type; 4801| | } 4802| | } 4803| | } 4804| | else { 4805| | // For variants with 0 or 1 object types, use the original error handling 4806| | ctx.error = error_code::no_matching_variant_type; 4807| | } 4808| | } 4809| 0| break; 4810| 5.39k| } 4811| 3| case '[': ------------------ | Branch (4811:13): [True: 3, False: 8.89k] ------------------ 4812| | // As with '{' above: the array reader each alternative goes through counts the level. 4813| 3| process_variant_alternatives::template op(value, ctx, it, end); 4814| 3| break; 4815| 3.47k| case '"': { ------------------ | Branch (4815:13): [True: 3.47k, False: 5.42k] ------------------ 4816| 3.47k| process_variant_alternatives::template op(value, ctx, it, end); 4817| 3.47k| break; 4818| 5.39k| } 4819| 3| case 't': ------------------ | Branch (4819:13): [True: 3, False: 8.89k] ------------------ 4820| 6| case 'f': { ------------------ | Branch (4820:13): [True: 3, False: 8.89k] ------------------ 4821| 6| process_variant_alternatives::template op(value, ctx, it, end); 4822| 6| break; 4823| 3| } 4824| 3| case 'n': ------------------ | Branch (4824:13): [True: 3, False: 8.89k] ------------------ 4825| 3| if constexpr (variant_count_v == 0) { 4826| 3| ctx.error = error_code::no_matching_variant_type; 4827| | } 4828| | else { 4829| | constexpr auto first_idx = variant_first_index_v; 4830| | using V = std::variant_alternative_t; 4831| | if (!std::holds_alternative(value)) value = V{}; 4832| | match<"null", Opts>(ctx, it, end); 4833| | } 4834| 3| break; 4835| 11| default: { ------------------ | Branch (4835:13): [True: 11, False: 8.88k] ------------------ 4836| | // Not bool, string, object, or array so must be number or null 4837| 11| process_variant_alternatives::template op(value, ctx, it, end); 4838| 11| } 4839| 8.89k| } 4840| | } 4841| | else { 4842| | // For non-auto-deducible variants, try each type until one succeeds 4843| | constexpr auto N = std::variant_size_v; 4844| | bool parsed = false; 4845| | bool exhausted = false; // speculation budget spent; see charge_speculation 4846| | 4847| | for_each([&]() { 4848| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4849| | 4850| | auto copy_it = it; 4851| | // A rejected alternative may have bailed out inside a container, which leaves its 4852| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4853| | const auto copy_depth = ctx.depth; 4854| | 4855| | // Try parsing as this type 4856| | if (value.index() != I) { 4857| | emplace_runtime_variant(value, I); 4858| | } 4859| | 4860| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4861| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4862| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4863| | } 4864| | 4865| | if (!bool(ctx.error)) { 4866| | parsed = true; 4867| | } 4868| | else if constexpr (not Options.null_terminated) { 4869| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4870| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4871| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4872| | // We advanced the iterator, so we did parse something -- unless what advanced it 4873| | // was an abandoned attempt, which is what a spent speculation budget means. 4874| | parsed = true; 4875| | ctx.error = error_code::none; 4876| | } 4877| | else { 4878| | // Reset for next attempt (unless this is the last type) 4879| | it = copy_it; 4880| | rewind_depth(ctx, copy_depth); 4881| | if constexpr (I + 1 < N) { 4882| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4883| | ctx.error = error_code::none; // Clear error for next attempt 4884| | } 4885| | } 4886| | } 4887| | } 4888| | else { 4889| | // Reset for next attempt (unless this is the last type) 4890| | it = copy_it; 4891| | rewind_depth(ctx, copy_depth); 4892| | if constexpr (I + 1 < N) { 4893| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4894| | ctx.error = error_code::none; // Clear error for next attempt 4895| | } 4896| | } 4897| | } 4898| | }); 4899| | } 4900| 8.89k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEERN9repe_fuzz6amountETkNS_10is_contextERNS_7contextERPKcSA_EEvOT0_OT1_OT2_T3_: 49| 13.3k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.3k| else { 60| 13.3k| using V = std::remove_cvref_t; 61| 13.3k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.3k| end); 63| 13.3k| } 64| 13.3k| } _ZN3glz4fromILj10EN9repe_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_: 3085| 13.3k| { 3086| 13.3k| static constexpr auto num_members = reflect::size; 3087| | 3088| 13.3k| static constexpr auto Opts = opening_handled_off()>(); 3089| | if constexpr (!check_opening_handled(Options)) { 3090| | if constexpr (!check_ws_handled(Options)) { 3091| | if (skip_ws(ctx, it, end)) { 3092| | return; 3093| | } 3094| | } 3095| | if (match_invalid_end<'{', Opts>(ctx, it, end)) { 3096| | return; 3097| | } 3098| | if constexpr (not Opts.null_terminated) { 3099| | if (it == end) [[unlikely]] { 3100| | ctx.error = error_code::unexpected_end; 3101| | return; 3102| | } 3103| | } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| | if (enter_depth(ctx)) [[unlikely]] { 3107| | return; 3108| | } 3109| | } 3110| 13.3k| const auto ws_start = it; 3111| 13.3k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 29, False: 13.2k] ------------------ 3112| 29| return; 3113| 29| } 3114| 13.2k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 13.2k| else { 3189| 13.2k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 13.2k| if constexpr ((glaze_object_t || reflectable) && 3191| 13.2k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 13.2k| return bit_array{}; 3193| 13.2k| } 3194| 13.2k| else { 3195| 13.2k| return nullptr; 3196| 13.2k| } 3197| 13.2k| }(); 3198| | 3199| 13.2k| size_t read_count{}; // for partial_read 3200| | 3201| 13.2k| bool first = true; 3202| 40.1k| while (true) { ------------------ | Branch (3202:20): [True: 32.5k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 32.5k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 5.38k, False: 27.1k] ------------------ 3240| 5.38k| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| 5.38k| if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| 5.38k| } 3265| 5.38k| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 5.38k| if constexpr (not Opts.null_terminated) { 3267| 5.38k| if (it == end) { ------------------ | Branch (3267:26): [True: 14, False: 5.37k] ------------------ 3268| 14| ctx.error = error_code::end_reached; 3269| 14| return; 3270| 14| } 3271| 5.38k| } 3272| 5.37k| return; 3273| 5.38k| } 3274| 27.1k| else if (first) { ------------------ | Branch (3274:25): [True: 7.89k, False: 19.2k] ------------------ 3275| 7.89k| first = false; 3276| 7.89k| } 3277| 19.2k| else { 3278| 19.2k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 238, False: 19.0k] ------------------ 3279| 238| return; 3280| 238| } 3281| 19.0k| if constexpr (not Opts.null_terminated) { 3282| 19.0k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 19.0k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 19.0k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| | (!Opts.comments)) { 3290| | if (ws_size && ws_size < size_t(end - it)) { 3291| | skip_matching_ws(ws_start, it, ws_size); 3292| | } 3293| | } 3294| | 3295| 19.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 18, False: 19.0k] ------------------ 3296| 18| return; 3297| 18| } 3298| 19.0k| } 3299| | 3300| 26.9k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [True: 0, Folded] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| 26.9k| else if constexpr (reflection_type) { 3364| 26.9k| static_assert(bool(hash_info.type)); 3365| | 3366| 26.9k| if (*it != '"') [[unlikely]] { ------------------ | Branch (3366:23): [True: 188, False: 26.7k] ------------------ 3367| 188| ctx.error = error_code::expected_quote; 3368| 188| return; 3369| 188| } 3370| 26.7k| ++it; 3371| 26.7k| if constexpr (not Opts.null_terminated) { 3372| 26.7k| if (it == end) [[unlikely]] { ------------------ | Branch (3372:26): [True: 14, False: 26.7k] ------------------ 3373| 14| ctx.error = error_code::unexpected_end; 3374| 14| return; 3375| 14| } 3376| 26.7k| } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| 26.7k| else { 3426| 26.7k| parse_and_invoke(value, ctx, it, end); 3427| 26.7k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3427:26): [True: 7.41k, False: 19.3k] ------------------ 3428| 7.41k| return; 3429| 26.7k| } 3430| | } 3431| | else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| | auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| | else { 3445| | parse::op()>(value[key], ctx, it, end); 3446| | } 3447| | }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| | using Key = typename T::key_type; 3451| | if constexpr (std::is_same_v) { 3452| | ctx.scratch.clear(); 3453| | parse::op(ctx.scratch, ctx, it, end); 3454| | if (bool(ctx.error)) [[unlikely]] 3455| | return; 3456| | 3457| | if (parse_ws_colon(ctx, it, end)) { 3458| | return; 3459| | } 3460| | 3461| | reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| | if (bool(ctx.error)) [[unlikely]] 3468| | return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| | } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 26.9k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 19, False: 26.9k] ------------------ 3539| 19| return; 3540| 19| } 3541| 26.9k| } 3542| 13.2k| } 3543| 13.2k| } _ZZN3glz4fromILj10EN9repe_fuzz6amountEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj1EEETnNS_14string_literalEXtlNS6_ILm1EEEEERS2_TkNS_10is_contextERNS_7contextERPKcSC_EEvOT1_OT2_OT3_T4_ENKUlvE_clEv: 3189| 13.2k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 13.2k| else { 3195| 13.2k| return nullptr; 3196| 13.2k| } 3197| 13.2k| }(); _ZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6amountERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_: 364| 26.7k| { 365| 26.7k| constexpr auto N = reflect::size; 366| | 367| 26.7k| if constexpr (N == 1) { 368| 26.7k| decode_index(value, ctx, it, end, selected_index...); 369| | } 370| | else if constexpr (check_linear_search(Opts)) { 371| | // Linear search path 372| | auto key_start = it; 373| | const auto index = decode_linear(ctx, it, end); 374| | if (bool(ctx.error)) [[unlikely]] 375| | return; 376| | 377| | if (index >= N) [[unlikely]] { 378| | if constexpr (Opts.error_on_unknown_keys) { 379| | ctx.error = error_code::unknown_key; 380| | return; 381| | } 382| | else { 383| | // it sits one past the closing quote, so the raw key spans [key_start, it - 1) 384| | if (validate_utf8_span(ctx, key_start, it - 1)) [[unlikely]] { 385| | return; 386| | } 387| | const sv key{key_start, size_t(it - key_start - 1)}; 388| | if constexpr (not Opts.null_terminated) { 389| | if (it == end) [[unlikely]] { 390| | ctx.error = error_code::unexpected_end; 391| | return; 392| | } 393| | } 394| | if (parse_ws_colon(ctx, it, end)) { 395| | return; 396| | } 397| | parse::handle_unknown(key, value, ctx, it, end); 398| | return; 399| | } 400| | } 401| | 402| | if constexpr (not Opts.null_terminated) { 403| | if (it == end) [[unlikely]] { 404| | ctx.error = error_code::unexpected_end; 405| | return; 406| | } 407| | } 408| | if (skip_ws(ctx, it, end)) { 409| | return; 410| | } 411| | if (match_invalid_end<':', Opts>(ctx, it, end)) { 412| | return; 413| | } 414| | if (skip_ws(ctx, it, end)) { 415| | return; 416| | } 417| | 418| | // Fold expression dispatch - avoids jump table overhead for smaller binary size 419| | auto parse_field = [&]() { 420| | if constexpr (check_skip_null_members_on_read(Opts)) { 421| | if (*it == 'n') { 422| | ++it; 423| | if constexpr (not Opts.null_terminated) { 424| | if (it == end) [[unlikely]] { 425| | ctx.error = error_code::unexpected_end; 426| | return; 427| | } 428| | } 429| | match<"ull", Opts>(ctx, it, end); 430| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 431| | ((selected_index = I), ...); 432| | } 433| | return; 434| | } 435| | } 436| | 437| | // Check for operation-specific skipping 438| | if constexpr (meta_has_skip>) { 439| | constexpr auto Key = get(reflect::keys); 440| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 441| | skip_value::op(ctx, it, end); 442| | if (bool(ctx.error)) [[unlikely]] 443| | return; 444| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 445| | ((selected_index = I), ...); 446| | } 447| | return; 448| | } 449| | } 450| | 451| | using V = refl_t; 452| | if constexpr (const_value_v) { 453| | if constexpr (check_error_on_const_read(Opts)) { 454| | ctx.error = error_code::attempt_const_read; 455| | } 456| | else { 457| | skip_value::op(ctx, it, end); 458| | } 459| | } 460| | else { 461| | // For linear_search, use Opts directly to avoid duplicate template instantiations 462| | // We've already skipped whitespace before reaching here 463| | if constexpr (glaze_object_t) { 464| | from>::template op(get_member(value, get(reflect::values)), 465| | ctx, it, end); 466| | } 467| | else { 468| | from>::template op(get_member(value, get(to_tie(value))), ctx, 469| | it, end); 470| | } 471| | } 472| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 473| | ((selected_index = I), ...); 474| | } 475| | }; 476| | [&](std::index_sequence) { 477| | (void)(((index == Is ? (parse_field.template operator()(), true) : false) || ...)); 478| | }(std::make_index_sequence{}); 479| | } 480| | else { 481| | // Hash-based lookup 482| | constexpr auto& HashInfo = hash_info; 483| | constexpr auto type = HashInfo.type; 484| | static_assert(bool(type), "invalid hash algorithm"); 485| | 486| | const auto index = decode_hash::op(it, end); 487| | 488| | if (index >= N) [[unlikely]] { 489| | if constexpr (Opts.error_on_unknown_keys) { 490| | ctx.error = error_code::unknown_key; 491| | return; 492| | } 493| | else { 494| | auto start = it; 495| | skip_string_view(ctx, it, end); 496| | if (bool(ctx.error)) [[unlikely]] 497| | return; 498| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 499| | return; 500| | const sv key = {start, size_t(it - start)}; 501| | ++it; // skip the quote 502| | if constexpr (not Opts.null_terminated) { 503| | if (it == end) [[unlikely]] { 504| | ctx.error = error_code::unexpected_end; 505| | return; 506| | } 507| | } 508| | if (parse_ws_colon(ctx, it, end)) { 509| | return; 510| | } 511| | parse::handle_unknown(key, value, ctx, it, end); 512| | return; 513| | } 514| | } 515| | 516| | if constexpr (N == 2) { 517| | if (index == 0) { 518| | decode_index(value, ctx, it, end, selected_index...); 519| | } 520| | else { 521| | decode_index(value, ctx, it, end, selected_index...); 522| | } 523| | } 524| | else { 525| | visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); 526| | } 527| | } 528| 26.7k| } _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6amountELm0ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 26.7k| { 235| 26.7k| static constexpr auto Key = get(reflect::keys); 236| 26.7k| static constexpr auto KeyWithEndQuote = join_v>; 237| 26.7k| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 26.7k| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 26.3k, False: 346] | Branch (239:36): [True: 19.5k, False: 6.80k] ------------------ 240| 19.5k| it += Length; 241| 19.5k| if constexpr (not Opts.null_terminated) { 242| 19.5k| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 19.5k] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 19.5k| } 247| | 248| 19.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 13, False: 19.5k] ------------------ 249| 13| return; 250| 13| } 251| 19.5k| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 23, False: 19.5k] ------------------ 252| 23| return; 253| 23| } 254| 19.5k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 13, False: 19.5k] ------------------ 255| 13| return; 256| 13| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 19.5k| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 19.5k| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 19.5k| else { 317| 19.5k| from>::template op()>( 318| 19.5k| get_member(value, get(to_tie(value))), ctx, it, end); 319| 19.5k| } 320| 19.5k| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 19.5k| } 326| 7.15k| else [[unlikely]] { 327| 7.15k| decode_index_unknown_key(value, ctx, it, end); 328| 7.15k| } 329| 26.7k| } _ZN3glz24decode_index_unknown_keyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6amountERS3_TkNS_10is_contextERNS_7contextERPKcS8_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT2_OT3_T4_: 177| 7.15k| { 178| 7.15k| if constexpr (Opts.error_on_unknown_keys) { 179| 7.15k| ctx.error = error_code::unknown_key; 180| | } 181| | else { 182| | auto* start = it; 183| | skip_string_view(ctx, it, end); 184| | if (bool(ctx.error)) [[unlikely]] 185| | return; 186| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 187| | return; 188| | const sv key = {start, size_t(it - start)}; 189| | ++it; 190| | if constexpr (not Opts.null_terminated) { 191| | if (it == end) [[unlikely]] { 192| | ctx.error = error_code::unexpected_end; 193| | return; 194| | } 195| | } 196| | 197| | if (parse_ws_colon(ctx, it, end)) { 198| | return; 199| | } 200| | 201| | parse::handle_unknown(key, value, ctx, it, end); 202| | } 203| 7.15k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_16is_variant_arrayEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3765| 1.98k| { 3766| 1.98k| constexpr auto category_count = variant_count_v; 3767| | 3768| 1.98k| if constexpr (category_count == 0) { 3769| 1.98k| ctx.error = error_code::no_matching_variant_type; 3770| | } 3771| | else { 3772| | constexpr auto N = std::variant_size_v; 3773| | constexpr auto const_count = variant_filtered_count_v; 3774| | constexpr auto non_const_count = variant_filtered_count_v; 3775| | 3776| | bool found_match{}; 3777| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3778| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3779| | // so the budget stops it and the failure already in hand is reported. 3780| | bool exhausted{}; 3781| | 3782| | // First pass: const glaze types in this category 3783| | if constexpr (const_count > 0) { 3784| | for_each([&]() { 3785| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3786| | return; 3787| | } 3788| | using V = std::variant_alternative_t; 3789| | if constexpr (Trait::value && glaze_const_value_t) { 3790| | // run time substitute to compare to const value 3791| | std::remove_const_t>>> substitute{}; 3792| | auto copy_it{it}; 3793| | // A rejected alternative may have bailed out inside a container, which leaves its 3794| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3795| | // trying N alternatives cannot spend N levels of the recursion budget. 3796| | const auto copy_depth{ctx.depth}; 3797| | parse::op()>(substitute, ctx, it, end); 3798| | static constexpr auto const_value{*meta_wrapper_v}; 3799| | if (substitute == const_value) { 3800| | found_match = true; 3801| | if (!std::holds_alternative(value)) { 3802| | value = V{}; 3803| | } 3804| | } 3805| | else { 3806| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3807| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3808| | exhausted = true; 3809| | } 3810| | if constexpr (not Options.null_terminated) { 3811| | if (ctx.error == error_code::end_reached && not exhausted) { 3812| | ctx.error = error_code::none; 3813| | } 3814| | } 3815| | it = copy_it; 3816| | rewind_depth(ctx, copy_depth); 3817| | } 3818| | } 3819| | }); 3820| | if (found_match) { 3821| | return; 3822| | } 3823| | } 3824| | 3825| | // Second pass: non-const types in this category 3826| | if constexpr (non_const_count > 0) { 3827| | // Track position within matching types for "is last" check. 3828| | // We iterate over all variant indices but only process matching types, 3829| | // so we need runtime tracking (vs the old tuple-based approach where 3830| | // the loop index directly corresponded to position in filtered set). 3831| | // This has negligible cost: one increment per matching type. 3832| | size_t non_const_idx = 0; 3833| | 3834| | for_each([&]() { 3835| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3836| | return; 3837| | } 3838| | using V = std::variant_alternative_t; 3839| | if constexpr (Trait::value && !glaze_const_value_t) { 3840| | auto copy_it{it}; 3841| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| | if (!std::holds_alternative(value)) { 3843| | value = V{}; 3844| | } 3845| | parse::op()>(std::get(value), ctx, it, end); 3846| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3847| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| | } 3849| | if (!bool(ctx.error)) { 3850| | found_match = true; 3851| | } 3852| | else if constexpr (not Options.null_terminated) { 3853| | constexpr bool is_complete_type = 3854| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3855| | 3856| | if constexpr (is_complete_type) { 3857| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3858| | found_match = true; 3859| | ctx.error = error_code::none; 3860| | } 3861| | else { 3862| | it = copy_it; 3863| | rewind_depth(ctx, copy_depth); 3864| | if (non_const_idx + 1 < non_const_count && not exhausted && 3865| | not variant_alternative_exhausted(ctx)) { 3866| | ctx.error = error_code::none; 3867| | } 3868| | } 3869| | } 3870| | else { 3871| | it = copy_it; 3872| | rewind_depth(ctx, copy_depth); 3873| | if (non_const_idx + 1 < non_const_count && not exhausted && 3874| | not variant_alternative_exhausted(ctx)) { 3875| | ctx.error = error_code::none; 3876| | } 3877| | } 3878| | } 3879| | else { 3880| | it = copy_it; 3881| | rewind_depth(ctx, copy_depth); 3882| | if (non_const_idx + 1 < non_const_count && not exhausted && 3883| | not variant_alternative_exhausted(ctx)) { 3884| | ctx.error = error_code::none; 3885| | } 3886| | } 3887| | ++non_const_idx; 3888| | } 3889| | }); 3890| | if (!found_match) { 3891| | if constexpr (non_const_count == 1) { 3892| | // Keep the specific error from the single type we tried 3893| | } 3894| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3895| | // Over-nested input is not a failure of the alternative set; keep saying so. 3896| | ctx.error = error_code::no_matching_variant_type; 3897| | } 3898| | } 3899| | } 3900| | else { 3901| | ctx.error = error_code::no_matching_variant_type; 3902| | } 3903| | } 3904| 1.98k| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3765| 4.47k| { 3766| 4.47k| constexpr auto category_count = variant_count_v; 3767| | 3768| | if constexpr (category_count == 0) { 3769| | ctx.error = error_code::no_matching_variant_type; 3770| | } 3771| 4.47k| else { 3772| 4.47k| constexpr auto N = std::variant_size_v; 3773| 4.47k| constexpr auto const_count = variant_filtered_count_v; 3774| 4.47k| constexpr auto non_const_count = variant_filtered_count_v; 3775| | 3776| 4.47k| bool found_match{}; 3777| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3778| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3779| | // so the budget stops it and the failure already in hand is reported. 3780| 4.47k| bool exhausted{}; 3781| | 3782| | // First pass: const glaze types in this category 3783| | if constexpr (const_count > 0) { 3784| | for_each([&]() { 3785| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3786| | return; 3787| | } 3788| | using V = std::variant_alternative_t; 3789| | if constexpr (Trait::value && glaze_const_value_t) { 3790| | // run time substitute to compare to const value 3791| | std::remove_const_t>>> substitute{}; 3792| | auto copy_it{it}; 3793| | // A rejected alternative may have bailed out inside a container, which leaves its 3794| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3795| | // trying N alternatives cannot spend N levels of the recursion budget. 3796| | const auto copy_depth{ctx.depth}; 3797| | parse::op()>(substitute, ctx, it, end); 3798| | static constexpr auto const_value{*meta_wrapper_v}; 3799| | if (substitute == const_value) { 3800| | found_match = true; 3801| | if (!std::holds_alternative(value)) { 3802| | value = V{}; 3803| | } 3804| | } 3805| | else { 3806| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3807| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3808| | exhausted = true; 3809| | } 3810| | if constexpr (not Options.null_terminated) { 3811| | if (ctx.error == error_code::end_reached && not exhausted) { 3812| | ctx.error = error_code::none; 3813| | } 3814| | } 3815| | it = copy_it; 3816| | rewind_depth(ctx, copy_depth); 3817| | } 3818| | } 3819| | }); 3820| | if (found_match) { 3821| | return; 3822| | } 3823| | } 3824| | 3825| | // Second pass: non-const types in this category 3826| 4.47k| if constexpr (non_const_count > 0) { 3827| | // Track position within matching types for "is last" check. 3828| | // We iterate over all variant indices but only process matching types, 3829| | // so we need runtime tracking (vs the old tuple-based approach where 3830| | // the loop index directly corresponded to position in filtered set). 3831| | // This has negligible cost: one increment per matching type. 3832| 4.47k| size_t non_const_idx = 0; 3833| | 3834| 4.47k| for_each([&]() { 3835| 4.47k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3836| 4.47k| return; 3837| 4.47k| } 3838| 4.47k| using V = std::variant_alternative_t; 3839| 4.47k| if constexpr (Trait::value && !glaze_const_value_t) { 3840| 4.47k| auto copy_it{it}; 3841| 4.47k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| 4.47k| if (!std::holds_alternative(value)) { 3843| 4.47k| value = V{}; 3844| 4.47k| } 3845| 4.47k| parse::op()>(std::get(value), ctx, it, end); 3846| 4.47k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3847| 4.47k| exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| 4.47k| } 3849| 4.47k| if (!bool(ctx.error)) { 3850| 4.47k| found_match = true; 3851| 4.47k| } 3852| 4.47k| else if constexpr (not Options.null_terminated) { 3853| 4.47k| constexpr bool is_complete_type = 3854| 4.47k| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3855| | 3856| 4.47k| if constexpr (is_complete_type) { 3857| 4.47k| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3858| 4.47k| found_match = true; 3859| 4.47k| ctx.error = error_code::none; 3860| 4.47k| } 3861| 4.47k| else { 3862| 4.47k| it = copy_it; 3863| 4.47k| rewind_depth(ctx, copy_depth); 3864| 4.47k| if (non_const_idx + 1 < non_const_count && not exhausted && 3865| 4.47k| not variant_alternative_exhausted(ctx)) { 3866| 4.47k| ctx.error = error_code::none; 3867| 4.47k| } 3868| 4.47k| } 3869| 4.47k| } 3870| 4.47k| else { 3871| 4.47k| it = copy_it; 3872| 4.47k| rewind_depth(ctx, copy_depth); 3873| 4.47k| if (non_const_idx + 1 < non_const_count && not exhausted && 3874| 4.47k| not variant_alternative_exhausted(ctx)) { 3875| 4.47k| ctx.error = error_code::none; 3876| 4.47k| } 3877| 4.47k| } 3878| 4.47k| } 3879| 4.47k| else { 3880| 4.47k| it = copy_it; 3881| 4.47k| rewind_depth(ctx, copy_depth); 3882| 4.47k| if (non_const_idx + 1 < non_const_count && not exhausted && 3883| 4.47k| not variant_alternative_exhausted(ctx)) { 3884| 4.47k| ctx.error = error_code::none; 3885| 4.47k| } 3886| 4.47k| } 3887| 4.47k| ++non_const_idx; 3888| 4.47k| } 3889| 4.47k| }); 3890| 4.47k| if (!found_match) { ------------------ | Branch (3890:20): [True: 593, False: 3.87k] ------------------ 3891| 593| if constexpr (non_const_count == 1) { 3892| | // Keep the specific error from the single type we tried 3893| | } 3894| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3895| | // Over-nested input is not a failure of the alternative set; keep saying so. 3896| | ctx.error = error_code::no_matching_variant_type; 3897| | } 3898| 593| } 3899| | } 3900| | else { 3901| | ctx.error = error_code::no_matching_variant_type; 3902| | } 3903| 4.47k| } 3904| 4.47k| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm0EEEDav: 3834| 4.47k| for_each([&]() { 3835| 4.47k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3835:23): [True: 0, False: 4.47k] | Branch (3835:38): [True: 0, False: 4.47k] | Branch (3835:51): [True: 0, False: 4.47k] ------------------ 3836| 0| return; 3837| 0| } 3838| 4.47k| using V = std::variant_alternative_t; 3839| 4.47k| if constexpr (Trait::value && !glaze_const_value_t) { 3840| 4.47k| auto copy_it{it}; 3841| 4.47k| const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| 4.47k| if (!std::holds_alternative(value)) { ------------------ | Branch (3842:26): [True: 1.18k, False: 3.28k] ------------------ 3843| 1.18k| value = V{}; 3844| 1.18k| } 3845| 4.47k| parse::op()>(std::get(value), ctx, it, end); 3846| 4.47k| if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { ------------------ | Branch (3846:26): [True: 659, False: 3.81k] | Branch (3846:45): [True: 0, False: 659] ------------------ 3847| 0| exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| 0| } 3849| 4.47k| if (!bool(ctx.error)) { ------------------ | Branch (3849:26): [True: 3.81k, False: 659] ------------------ 3850| 3.81k| found_match = true; 3851| 3.81k| } 3852| 659| else if constexpr (not Options.null_terminated) { 3853| 659| constexpr bool is_complete_type = 3854| 659| num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; ------------------ | Branch (3854:28): [Folded, False: 0] | Branch (3854:40): [Folded, False: 0] | Branch (3854:53): [True: 0, Folded] | Branch (3854:68): [Folded, False: 0] | Branch (3854:89): [Folded, False: 0] | Branch (3854:103): [Folded, False: 0] ------------------ 3855| | 3856| 659| if constexpr (is_complete_type) { 3857| 659| if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { ------------------ | Branch (3857:32): [True: 66, False: 593] | Branch (3857:72): [True: 66, False: 0] | Branch (3857:88): [True: 66, False: 0] ------------------ 3858| 66| found_match = true; 3859| 66| ctx.error = error_code::none; 3860| 66| } 3861| 593| else { 3862| 593| it = copy_it; 3863| 593| rewind_depth(ctx, copy_depth); 3864| 593| if (non_const_idx + 1 < non_const_count && not exhausted && ------------------ | Branch (3864:35): [True: 0, False: 593] | Branch (3864:74): [True: 0, False: 0] ------------------ 3865| 0| not variant_alternative_exhausted(ctx)) { ------------------ | Branch (3865:35): [True: 0, False: 0] ------------------ 3866| 0| ctx.error = error_code::none; 3867| 0| } 3868| 593| } 3869| | } 3870| | else { 3871| | it = copy_it; 3872| | rewind_depth(ctx, copy_depth); 3873| | if (non_const_idx + 1 < non_const_count && not exhausted && 3874| | not variant_alternative_exhausted(ctx)) { 3875| | ctx.error = error_code::none; 3876| | } 3877| | } 3878| | } 3879| | else { 3880| | it = copy_it; 3881| | rewind_depth(ctx, copy_depth); 3882| | if (non_const_idx + 1 < non_const_count && not exhausted && 3883| | not variant_alternative_exhausted(ctx)) { 3884| | ctx.error = error_code::none; 3885| | } 3886| | } 3887| 4.47k| ++non_const_idx; 3888| 4.47k| } 3889| 4.47k| }); _ZN3glz29variant_alternative_exhaustedITkNS_10is_contextENS_7contextEEEbRT_: 3754| 5.06k| { 3755| 5.06k| return ctx.error == error_code::exceeded_max_recursive_depth; 3756| 5.06k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETkNS_10is_contextERNS_7contextERPKcSF_EEvOT0_OT1_OT2_T3_: 49| 4.47k| { 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.47k| else { 60| 4.47k| using V = std::remove_cvref_t; 61| 4.47k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 4.47k| end); 63| 4.47k| } 64| 4.47k| } _ZN3glz12rewind_depthITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextENS_7contextEEEvRT0_j: 3737| 593| { 3738| 593| if (ctx.error == error_code::exceeded_max_recursive_depth) [[unlikely]] { ------------------ | Branch (3738:11): [True: 0, False: 593] ------------------ 3739| 0| return; 3740| 0| } 3741| | if constexpr (Opts.null_terminated) { 3742| | ctx.depth = depth; 3743| | } 3744| 593| else { 3745| 593| if (ctx.error != error_code::end_reached && ctx.error != error_code::unexpected_end) { ------------------ | Branch (3745:14): [True: 593, False: 0] | Branch (3745:54): [True: 490, False: 103] ------------------ 3746| 490| ctx.depth = depth; 3747| 490| } 3748| 593| } 3749| 593| } _ZZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_ENKUlTnmvE_clILm1EEEDav: 3834| 4.47k| for_each([&]() { 3835| 4.47k| if (found_match || exhausted || variant_alternative_exhausted(ctx)) { ------------------ | Branch (3835:23): [True: 3.87k, False: 593] | Branch (3835:38): [True: 0, False: 593] | Branch (3835:51): [True: 0, False: 593] ------------------ 3836| 3.87k| return; 3837| 3.87k| } 3838| 593| using V = std::variant_alternative_t; 3839| | if constexpr (Trait::value && !glaze_const_value_t) { 3840| | auto copy_it{it}; 3841| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| | if (!std::holds_alternative(value)) { 3843| | value = V{}; 3844| | } 3845| | parse::op()>(std::get(value), ctx, it, end); 3846| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3847| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| | } 3849| | if (!bool(ctx.error)) { 3850| | found_match = true; 3851| | } 3852| | else if constexpr (not Options.null_terminated) { 3853| | constexpr bool is_complete_type = 3854| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3855| | 3856| | if constexpr (is_complete_type) { 3857| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3858| | found_match = true; 3859| | ctx.error = error_code::none; 3860| | } 3861| | else { 3862| | it = copy_it; 3863| | rewind_depth(ctx, copy_depth); 3864| | if (non_const_idx + 1 < non_const_count && not exhausted && 3865| | not variant_alternative_exhausted(ctx)) { 3866| | ctx.error = error_code::none; 3867| | } 3868| | } 3869| | } 3870| | else { 3871| | it = copy_it; 3872| | rewind_depth(ctx, copy_depth); 3873| | if (non_const_idx + 1 < non_const_count && not exhausted && 3874| | not variant_alternative_exhausted(ctx)) { 3875| | ctx.error = error_code::none; 3876| | } 3877| | } 3878| | } 3879| | else { 3880| | it = copy_it; 3881| | rewind_depth(ctx, copy_depth); 3882| | if (non_const_idx + 1 < non_const_count && not exhausted && 3883| | not variant_alternative_exhausted(ctx)) { 3884| | ctx.error = error_code::none; 3885| | } 3886| | } 3887| | ++non_const_idx; 3888| | } 3889| 593| }); _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_15is_variant_boolEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3765| 12| { 3766| 12| constexpr auto category_count = variant_count_v; 3767| | 3768| 12| if constexpr (category_count == 0) { 3769| 12| ctx.error = error_code::no_matching_variant_type; 3770| | } 3771| | else { 3772| | constexpr auto N = std::variant_size_v; 3773| | constexpr auto const_count = variant_filtered_count_v; 3774| | constexpr auto non_const_count = variant_filtered_count_v; 3775| | 3776| | bool found_match{}; 3777| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3778| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3779| | // so the budget stops it and the failure already in hand is reported. 3780| | bool exhausted{}; 3781| | 3782| | // First pass: const glaze types in this category 3783| | if constexpr (const_count > 0) { 3784| | for_each([&]() { 3785| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3786| | return; 3787| | } 3788| | using V = std::variant_alternative_t; 3789| | if constexpr (Trait::value && glaze_const_value_t) { 3790| | // run time substitute to compare to const value 3791| | std::remove_const_t>>> substitute{}; 3792| | auto copy_it{it}; 3793| | // A rejected alternative may have bailed out inside a container, which leaves its 3794| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3795| | // trying N alternatives cannot spend N levels of the recursion budget. 3796| | const auto copy_depth{ctx.depth}; 3797| | parse::op()>(substitute, ctx, it, end); 3798| | static constexpr auto const_value{*meta_wrapper_v}; 3799| | if (substitute == const_value) { 3800| | found_match = true; 3801| | if (!std::holds_alternative(value)) { 3802| | value = V{}; 3803| | } 3804| | } 3805| | else { 3806| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3807| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3808| | exhausted = true; 3809| | } 3810| | if constexpr (not Options.null_terminated) { 3811| | if (ctx.error == error_code::end_reached && not exhausted) { 3812| | ctx.error = error_code::none; 3813| | } 3814| | } 3815| | it = copy_it; 3816| | rewind_depth(ctx, copy_depth); 3817| | } 3818| | } 3819| | }); 3820| | if (found_match) { 3821| | return; 3822| | } 3823| | } 3824| | 3825| | // Second pass: non-const types in this category 3826| | if constexpr (non_const_count > 0) { 3827| | // Track position within matching types for "is last" check. 3828| | // We iterate over all variant indices but only process matching types, 3829| | // so we need runtime tracking (vs the old tuple-based approach where 3830| | // the loop index directly corresponded to position in filtered set). 3831| | // This has negligible cost: one increment per matching type. 3832| | size_t non_const_idx = 0; 3833| | 3834| | for_each([&]() { 3835| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3836| | return; 3837| | } 3838| | using V = std::variant_alternative_t; 3839| | if constexpr (Trait::value && !glaze_const_value_t) { 3840| | auto copy_it{it}; 3841| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| | if (!std::holds_alternative(value)) { 3843| | value = V{}; 3844| | } 3845| | parse::op()>(std::get(value), ctx, it, end); 3846| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3847| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| | } 3849| | if (!bool(ctx.error)) { 3850| | found_match = true; 3851| | } 3852| | else if constexpr (not Options.null_terminated) { 3853| | constexpr bool is_complete_type = 3854| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3855| | 3856| | if constexpr (is_complete_type) { 3857| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3858| | found_match = true; 3859| | ctx.error = error_code::none; 3860| | } 3861| | else { 3862| | it = copy_it; 3863| | rewind_depth(ctx, copy_depth); 3864| | if (non_const_idx + 1 < non_const_count && not exhausted && 3865| | not variant_alternative_exhausted(ctx)) { 3866| | ctx.error = error_code::none; 3867| | } 3868| | } 3869| | } 3870| | else { 3871| | it = copy_it; 3872| | rewind_depth(ctx, copy_depth); 3873| | if (non_const_idx + 1 < non_const_count && not exhausted && 3874| | not variant_alternative_exhausted(ctx)) { 3875| | ctx.error = error_code::none; 3876| | } 3877| | } 3878| | } 3879| | else { 3880| | it = copy_it; 3881| | rewind_depth(ctx, copy_depth); 3882| | if (non_const_idx + 1 < non_const_count && not exhausted && 3883| | not variant_alternative_exhausted(ctx)) { 3884| | ctx.error = error_code::none; 3885| | } 3886| | } 3887| | ++non_const_idx; 3888| | } 3889| | }); 3890| | if (!found_match) { 3891| | if constexpr (non_const_count == 1) { 3892| | // Keep the specific error from the single type we tried 3893| | } 3894| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3895| | // Over-nested input is not a failure of the alternative set; keep saying so. 3896| | ctx.error = error_code::no_matching_variant_type; 3897| | } 3898| | } 3899| | } 3900| | else { 3901| | ctx.error = error_code::no_matching_variant_type; 3902| | } 3903| | } 3904| 12| } _ZN3glz28process_variant_alternativesINSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_14is_variant_numEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSK_EEvOT0_OT1_OT2_T3_: 3765| 1.89k| { 3766| 1.89k| constexpr auto category_count = variant_count_v; 3767| | 3768| 1.89k| if constexpr (category_count == 0) { 3769| 1.89k| ctx.error = error_code::no_matching_variant_type; 3770| | } 3771| | else { 3772| | constexpr auto N = std::variant_size_v; 3773| | constexpr auto const_count = variant_filtered_count_v; 3774| | constexpr auto non_const_count = variant_filtered_count_v; 3775| | 3776| | bool found_match{}; 3777| | // Set when the speculative parsing budget runs out; see charge_speculation. An ambiguous 3778| | // nest re-parses the same subtree per alternative at every level, which is exponential, 3779| | // so the budget stops it and the failure already in hand is reported. 3780| | bool exhausted{}; 3781| | 3782| | // First pass: const glaze types in this category 3783| | if constexpr (const_count > 0) { 3784| | for_each([&]() { 3785| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3786| | return; 3787| | } 3788| | using V = std::variant_alternative_t; 3789| | if constexpr (Trait::value && glaze_const_value_t) { 3790| | // run time substitute to compare to const value 3791| | std::remove_const_t>>> substitute{}; 3792| | auto copy_it{it}; 3793| | // A rejected alternative may have bailed out inside a container, which leaves its 3794| | // nesting level counted (see enter_depth). Rewind the depth with the iterator so 3795| | // trying N alternatives cannot spend N levels of the recursion budget. 3796| | const auto copy_depth{ctx.depth}; 3797| | parse::op()>(substitute, ctx, it, end); 3798| | static constexpr auto const_value{*meta_wrapper_v}; 3799| | if (substitute == const_value) { 3800| | found_match = true; 3801| | if (!std::holds_alternative(value)) { 3802| | value = V{}; 3803| | } 3804| | } 3805| | else { 3806| | // Rejected: charge the bytes it parsed before we rewind. See charge_speculation. 3807| | if (!charge_speculation(ctx, size_t(it - copy_it))) { 3808| | exhausted = true; 3809| | } 3810| | if constexpr (not Options.null_terminated) { 3811| | if (ctx.error == error_code::end_reached && not exhausted) { 3812| | ctx.error = error_code::none; 3813| | } 3814| | } 3815| | it = copy_it; 3816| | rewind_depth(ctx, copy_depth); 3817| | } 3818| | } 3819| | }); 3820| | if (found_match) { 3821| | return; 3822| | } 3823| | } 3824| | 3825| | // Second pass: non-const types in this category 3826| | if constexpr (non_const_count > 0) { 3827| | // Track position within matching types for "is last" check. 3828| | // We iterate over all variant indices but only process matching types, 3829| | // so we need runtime tracking (vs the old tuple-based approach where 3830| | // the loop index directly corresponded to position in filtered set). 3831| | // This has negligible cost: one increment per matching type. 3832| | size_t non_const_idx = 0; 3833| | 3834| | for_each([&]() { 3835| | if (found_match || exhausted || variant_alternative_exhausted(ctx)) { 3836| | return; 3837| | } 3838| | using V = std::variant_alternative_t; 3839| | if constexpr (Trait::value && !glaze_const_value_t) { 3840| | auto copy_it{it}; 3841| | const auto copy_depth{ctx.depth}; // rewound with `it`; see the note above 3842| | if (!std::holds_alternative(value)) { 3843| | value = V{}; 3844| | } 3845| | parse::op()>(std::get(value), ctx, it, end); 3846| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 3847| | exhausted = true; // only rejected attempts are charged; see charge_speculation 3848| | } 3849| | if (!bool(ctx.error)) { 3850| | found_match = true; 3851| | } 3852| | else if constexpr (not Options.null_terminated) { 3853| | constexpr bool is_complete_type = 3854| | num_t || bool_t || string_t || std::is_enum_v || tuple_t || is_std_tuple; 3855| | 3856| | if constexpr (is_complete_type) { 3857| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 3858| | found_match = true; 3859| | ctx.error = error_code::none; 3860| | } 3861| | else { 3862| | it = copy_it; 3863| | rewind_depth(ctx, copy_depth); 3864| | if (non_const_idx + 1 < non_const_count && not exhausted && 3865| | not variant_alternative_exhausted(ctx)) { 3866| | ctx.error = error_code::none; 3867| | } 3868| | } 3869| | } 3870| | else { 3871| | it = copy_it; 3872| | rewind_depth(ctx, copy_depth); 3873| | if (non_const_idx + 1 < non_const_count && not exhausted && 3874| | not variant_alternative_exhausted(ctx)) { 3875| | ctx.error = error_code::none; 3876| | } 3877| | } 3878| | } 3879| | else { 3880| | it = copy_it; 3881| | rewind_depth(ctx, copy_depth); 3882| | if (non_const_idx + 1 < non_const_count && not exhausted && 3883| | not variant_alternative_exhausted(ctx)) { 3884| | ctx.error = error_code::none; 3885| | } 3886| | } 3887| | ++non_const_idx; 3888| | } 3889| | }); 3890| | if (!found_match) { 3891| | if constexpr (non_const_count == 1) { 3892| | // Keep the specific error from the single type we tried 3893| | } 3894| | else if (not exhausted && not variant_alternative_exhausted(ctx)) { 3895| | // Over-nested input is not a failure of the alternative set; keep saying so. 3896| | ctx.error = error_code::no_matching_variant_type; 3897| | } 3898| | } 3899| | } 3900| | else { 3901| | ctx.error = error_code::no_matching_variant_type; 3902| | } 3903| | } 3904| 1.89k| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm8EEEDav: 525| 323| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm8ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 323| { 235| 323| static constexpr auto Key = get(reflect::keys); 236| 323| static constexpr auto KeyWithEndQuote = join_v>; 237| 323| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 323| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 315, False: 8] | Branch (239:36): [True: 141, False: 174] ------------------ 240| 141| it += Length; 241| 141| if constexpr (not Opts.null_terminated) { 242| 141| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 141] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 141| } 247| | 248| 141| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 129] ------------------ 249| 12| return; 250| 12| } 251| 129| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 9, False: 120] ------------------ 252| 9| return; 253| 9| } 254| 120| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 106] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 106| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 106| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 106| else { 317| 106| from>::template op()>( 318| 106| get_member(value, get(to_tie(value))), ctx, it, end); 319| 106| } 320| 106| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 106| } 326| 182| else [[unlikely]] { 327| 182| decode_index_unknown_key(value, ctx, it, end); 328| 182| } 329| 323| } _ZN3glz4fromILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 2220| 106| { 2221| | if constexpr (!check_ws_handled(Opts)) { 2222| | if (skip_ws(ctx, it, end)) { 2223| | return; 2224| | } 2225| | } 2226| 106| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2226:14): [True: 9, False: 97] ------------------ 2227| 9| return; 2228| 9| } 2229| 97| skip_string_view(ctx, it, end); 2230| 97| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2230:14): [True: 17, False: 80] ------------------ 2231| 17| return; 2232| 80| if (match<'"'>(ctx, it)) { ------------------ | Branch (2232:14): [True: 0, False: 80] ------------------ 2233| 0| return; 2234| 0| } 2235| 80| if constexpr (not Opts.null_terminated) { 2236| 80| if (it == end) { ------------------ | Branch (2236:17): [True: 5, False: 75] ------------------ 2237| 5| ctx.error = error_code::end_reached; 2238| 5| return; 2239| 5| } 2240| 80| } 2241| 80| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm9EEEDav: 525| 126| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm9ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 126| { 235| 126| static constexpr auto Key = get(reflect::keys); 236| 126| static constexpr auto KeyWithEndQuote = join_v>; 237| 126| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 126| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 121, False: 5] | Branch (239:36): [True: 115, False: 6] ------------------ 240| 115| it += Length; 241| 115| if constexpr (not Opts.null_terminated) { 242| 115| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 115] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 115| } 247| | 248| 115| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 103] ------------------ 249| 12| return; 250| 12| } 251| 103| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 9, False: 94] ------------------ 252| 9| return; 253| 9| } 254| 94| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 80] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 80| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 80| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 80| else { 317| 80| from>::template op()>( 318| 80| get_member(value, get(to_tie(value))), ctx, it, end); 319| 80| } 320| 80| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 80| } 326| 11| else [[unlikely]] { 327| 11| decode_index_unknown_key(value, ctx, it, end); 328| 11| } 329| 126| } _ZN3glz4fromILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEESC_TkNS_10is_contextERNS_7contextERPKcSJ_EEvRT0_OT1_OT2_T3_: 2220| 80| { 2221| | if constexpr (!check_ws_handled(Opts)) { 2222| | if (skip_ws(ctx, it, end)) { 2223| | return; 2224| | } 2225| | } 2226| 80| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2226:14): [True: 10, False: 70] ------------------ 2227| 10| return; 2228| 10| } 2229| 70| skip_string_view(ctx, it, end); 2230| 70| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2230:14): [True: 19, False: 51] ------------------ 2231| 19| return; 2232| 51| if (match<'"'>(ctx, it)) { ------------------ | Branch (2232:14): [True: 0, False: 51] ------------------ 2233| 0| return; 2234| 0| } 2235| 51| if constexpr (not Opts.null_terminated) { 2236| 51| if (it == end) { ------------------ | Branch (2236:17): [True: 5, False: 46] ------------------ 2237| 5| ctx.error = error_code::end_reached; 2238| 5| return; 2239| 5| } 2240| 51| } 2241| 51| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm10EEEDav: 525| 350| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm10ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 350| { 235| 350| static constexpr auto Key = get(reflect::keys); 236| 350| static constexpr auto KeyWithEndQuote = join_v>; 237| 350| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 350| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 343, False: 7] | Branch (239:36): [True: 303, False: 40] ------------------ 240| 303| it += Length; 241| 303| if constexpr (not Opts.null_terminated) { 242| 303| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 303] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 303| } 247| | 248| 303| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 14, False: 289] ------------------ 249| 14| return; 250| 14| } 251| 289| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 9, False: 280] ------------------ 252| 9| return; 253| 9| } 254| 280| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 16, False: 264] ------------------ 255| 16| return; 256| 16| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 264| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 264| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 264| else { 317| 264| from>::template op()>( 318| 264| get_member(value, get(to_tie(value))), ctx, it, end); 319| 264| } 320| 264| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 264| } 326| 47| else [[unlikely]] { 327| 47| decode_index_unknown_key(value, ctx, it, end); 328| 47| } 329| 350| } _ZN3glz4fromILj10ENSt3__18functionIFN9repe_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES8_TkNS_10is_contextERNS_7contextERPKcSF_EEvRT0_OT1_OT2_T3_: 2220| 264| { 2221| | if constexpr (!check_ws_handled(Opts)) { 2222| | if (skip_ws(ctx, it, end)) { 2223| | return; 2224| | } 2225| | } 2226| 264| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2226:14): [True: 6, False: 258] ------------------ 2227| 6| return; 2228| 6| } 2229| 258| skip_string_view(ctx, it, end); 2230| 258| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2230:14): [True: 18, False: 240] ------------------ 2231| 18| return; 2232| 240| if (match<'"'>(ctx, it)) { ------------------ | Branch (2232:14): [True: 0, False: 240] ------------------ 2233| 0| return; 2234| 0| } 2235| 240| if constexpr (not Opts.null_terminated) { 2236| 240| if (it == end) { ------------------ | Branch (2236:17): [True: 9, False: 231] ------------------ 2237| 9| ctx.error = error_code::end_reached; 2238| 9| return; 2239| 9| } 2240| 240| } 2241| 240| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm11EEEDav: 525| 102| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm11ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 102| { 235| 102| static constexpr auto Key = get(reflect::keys); 236| 102| static constexpr auto KeyWithEndQuote = join_v>; 237| 102| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 102| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 96, False: 6] | Branch (239:36): [True: 89, False: 7] ------------------ 240| 89| it += Length; 241| 89| if constexpr (not Opts.null_terminated) { 242| 89| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 89] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 89| } 247| | 248| 89| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 77] ------------------ 249| 12| return; 250| 12| } 251| 77| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 9, False: 68] ------------------ 252| 9| return; 253| 9| } 254| 68| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 14, False: 54] ------------------ 255| 14| return; 256| 14| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 54| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 54| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 54| else { 317| 54| from>::template op()>( 318| 54| get_member(value, get(to_tie(value))), ctx, it, end); 319| 54| } 320| 54| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 54| } 326| 13| else [[unlikely]] { 327| 13| decode_index_unknown_key(value, ctx, it, end); 328| 13| } 329| 102| } _ZN3glz4fromILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES9_TkNS_10is_contextERNS_7contextERPKcSG_EEvRT0_OT1_OT2_T3_: 2220| 54| { 2221| | if constexpr (!check_ws_handled(Opts)) { 2222| | if (skip_ws(ctx, it, end)) { 2223| | return; 2224| | } 2225| | } 2226| 54| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2226:14): [True: 10, False: 44] ------------------ 2227| 10| return; 2228| 10| } 2229| 44| skip_string_view(ctx, it, end); 2230| 44| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2230:14): [True: 13, False: 31] ------------------ 2231| 13| return; 2232| 31| if (match<'"'>(ctx, it)) { ------------------ | Branch (2232:14): [True: 0, False: 31] ------------------ 2233| 0| return; 2234| 0| } 2235| 31| if constexpr (not Opts.null_terminated) { 2236| 31| if (it == end) { ------------------ | Branch (2236:17): [True: 5, False: 26] ------------------ 2237| 5| ctx.error = error_code::end_reached; 2238| 5| return; 2239| 5| } 2240| 31| } 2241| 31| } _ZZN3glz16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT1_OT3_OT4_OT5_DpOT2_ENKUlTnmvE_clILm12EEEDav: 525| 106| visit([&]() { decode_index(value, ctx, it, end, selected_index...); }, index); _ZN3glz12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm12ERS3_JETkNS_10is_contextERNS_7contextERPKcS9_Qoo14glaze_object_tIT0_E11reflectableISA_EEEvOT2_OT4_OT5_OT6_DpOT3_: 234| 106| { 235| 106| static constexpr auto Key = get(reflect::keys); 236| 106| static constexpr auto KeyWithEndQuote = join_v>; 237| 106| static constexpr auto Length = KeyWithEndQuote.size(); 238| | 239| 106| if (((it + Length) < end) && comparitor(it)) [[likely]] { ------------------ | Branch (239:11): [True: 101, False: 5] | Branch (239:36): [True: 92, False: 9] ------------------ 240| 92| it += Length; 241| 92| if constexpr (not Opts.null_terminated) { 242| 92| if (it == end) [[unlikely]] { ------------------ | Branch (242:17): [True: 0, False: 92] ------------------ 243| 0| ctx.error = error_code::unexpected_end; 244| 0| return; 245| 0| } 246| 92| } 247| | 248| 92| if (skip_ws(ctx, it, end)) { ------------------ | Branch (248:14): [True: 12, False: 80] ------------------ 249| 12| return; 250| 12| } 251| 80| if (match_invalid_end<':', Opts>(ctx, it, end)) { ------------------ | Branch (251:14): [True: 12, False: 68] ------------------ 252| 12| return; 253| 12| } 254| 68| if (skip_ws(ctx, it, end)) { ------------------ | Branch (254:14): [True: 12, False: 56] ------------------ 255| 12| return; 256| 12| } 257| | 258| | // Check for null value skipping on read 259| | if constexpr (check_skip_null_members_on_read(Opts)) { 260| | if (*it == 'n') { 261| | ++it; 262| | if constexpr (not Opts.null_terminated) { 263| | if (it == end) [[unlikely]] { 264| | ctx.error = error_code::unexpected_end; 265| | return; 266| | } 267| | } 268| | match<"ull", Opts>(ctx, it, end); 269| | if (bool(ctx.error)) [[unlikely]] 270| | return; 271| | // Successfully matched "null", skip it 272| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 273| | ((selected_index = I), ...); // Mark as handled even if skipped 274| | } 275| | return; 276| | } 277| | } 278| | 279| | // Check for operation-specific skipping 280| | if constexpr (meta_has_skip>) { 281| | if constexpr (meta>::skip(Key, {glz::operation::parse})) { 282| | skip_value::op(ctx, it, end); 283| | if (bool(ctx.error)) [[unlikely]] 284| | return; // Propagate error from skip_value 285| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 286| | ((selected_index = I), ...); // Mark as handled even if skipped 287| | } 288| | return; 289| | } 290| | } 291| | 292| 56| using V = refl_t; 293| | 294| | if constexpr (const_value_v) { 295| | if constexpr (check_error_on_const_read(Opts)) { 296| | ctx.error = error_code::attempt_const_read; 297| | } 298| | else { 299| | // do not read anything into the const value 300| | skip_value::op(ctx, it, end); 301| | } 302| | } 303| | else if constexpr (is_function_ptr_or_ref) { 304| | // Function pointers cannot be deserialized from JSON. 305| | // When write_function_pointers is enabled the writer emits a type-name string, 306| | // but there is nothing meaningful to reconstruct on read — just skip the value. 307| | // When write_function_pointers is off the key is never written, so this branch 308| | // is unreachable in that case. 309| | skip_value::op(ctx, it, end); 310| | } 311| 56| else { 312| | if constexpr (glaze_object_t) { 313| | from>::template op()>( 314| | get_member(value, get(reflect::values)), ctx, it, end); 315| | } 316| 56| else { 317| 56| from>::template op()>( 318| 56| get_member(value, get(to_tie(value))), ctx, it, end); 319| 56| } 320| 56| } 321| | 322| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 323| | ((selected_index = I), ...); 324| | } 325| 56| } 326| 14| else [[unlikely]] { 327| 14| decode_index_unknown_key(value, ctx, it, end); 328| 14| } 329| 106| } _ZN3glz4fromILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEES4_TkNS_10is_contextERNS_7contextERPKcSB_EEvRT0_OT1_OT2_T3_: 2220| 56| { 2221| | if constexpr (!check_ws_handled(Opts)) { 2222| | if (skip_ws(ctx, it, end)) { 2223| | return; 2224| | } 2225| | } 2226| 56| if (match_invalid_end<'"', Opts>(ctx, it, end)) { ------------------ | Branch (2226:14): [True: 18, False: 38] ------------------ 2227| 18| return; 2228| 18| } 2229| 38| skip_string_view(ctx, it, end); 2230| 38| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2230:14): [True: 20, False: 18] ------------------ 2231| 20| return; 2232| 18| if (match<'"'>(ctx, it)) { ------------------ | Branch (2232:14): [True: 0, False: 18] ------------------ 2233| 0| return; 2234| 0| } 2235| 18| if constexpr (not Opts.null_terminated) { 2236| 18| if (it == end) { ------------------ | Branch (2236:17): [True: 7, False: 11] ------------------ 2237| 7| ctx.error = error_code::end_reached; 2238| 7| return; 2239| 7| } 2240| 18| } 2241| 18| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS4_9allocatorIiEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 13.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.0k| else { 60| 13.0k| using V = std::remove_cvref_t; 61| 13.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.0k| end); 63| 13.0k| } 64| 13.0k| } _ZN3glz4fromILj10ENSt3__16vectorIiNS1_9allocatorIiEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2349| 13.0k| { 2350| 13.0k| constexpr auto Opts = ws_handled_off(); 2351| 13.0k| if constexpr (!check_ws_handled(Options)) { 2352| 13.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2352:17): [True: 34, False: 13.0k] ------------------ 2353| 34| return; 2354| 34| } 2355| 13.0k| } 2356| | 2357| 13.0k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2357:14): [True: 11.0k, False: 2.02k] ------------------ 2358| 11.0k| return; 2359| 11.0k| } 2360| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2361| | // released at each syntactic close below 2362| 2.02k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2362:14): [True: 0, False: 2.02k] ------------------ 2363| 0| return; 2364| 0| } 2365| | 2366| 2.02k| const auto ws_start = it; 2367| 2.02k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:14): [True: 14, False: 2.01k] ------------------ 2368| 14| return; 2369| 14| } 2370| | 2371| 2.01k| if (*it == ']') { ------------------ | Branch (2371:14): [True: 5, False: 2.00k] ------------------ 2372| 5| --ctx.depth; 2373| 5| ++it; 2374| 5| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2375| 5| value.clear(); 2376| | 2377| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2378| | value.shrink_to_fit(); 2379| | } 2380| 5| } 2381| 5| return; 2382| 5| } 2383| | 2384| 2.00k| const size_t ws_size = size_t(it - ws_start); 2385| | 2386| 2.00k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2386:49): [True: 2.00k, Folded] | Branch (2386:65): [Folded, False: 0] | Branch (2386:90): [Folded, False: 0] ------------------ 2387| 2.00k| if constexpr (not should_append) { 2388| 2.00k| const auto n = value.size(); 2389| | 2390| 2.00k| auto value_it = value.begin(); 2391| | 2392| 2.00k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2392:32): [True: 0, False: 2.00k] ------------------ 2393| 0| parse::op()>(*value_it++, ctx, it, end); 2394| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2394:20): [True: 0, False: 0] ------------------ 2395| 0| return; 2396| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2396:20): [True: 0, False: 0] ------------------ 2397| 0| return; 2398| 0| } 2399| 0| if (*it == ',') { ------------------ | Branch (2399:20): [True: 0, False: 0] ------------------ 2400| 0| ++it; 2401| | 2402| 0| if constexpr (!Opts.minified && !Opts.comments) { 2403| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2403:26): [True: 0, False: 0] | Branch (2403:37): [True: 0, False: 0] ------------------ 2404| 0| skip_matching_ws(ws_start, it, ws_size); 2405| 0| } 2406| 0| } 2407| | 2408| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2408:23): [True: 0, False: 0] ------------------ 2409| 0| return; 2410| 0| } 2411| 0| } 2412| 0| else if (*it == ']') { ------------------ | Branch (2412:25): [True: 0, False: 0] ------------------ 2413| 0| --ctx.depth; 2414| 0| ++it; 2415| 0| if constexpr (erasable) { 2416| 0| value.erase(value_it, 2417| 0| value.end()); // use erase rather than resize for non-default constructible elements 2418| | 2419| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2420| | value.shrink_to_fit(); 2421| | } 2422| 0| } 2423| 0| return; 2424| 0| } 2425| 0| else [[unlikely]] { 2426| 0| ctx.error = error_code::expected_bracket; 2427| 0| return; 2428| 0| } 2429| 0| } 2430| 2.00k| } 2431| | 2432| | if constexpr (Opts.partial_read) { 2433| | // partial_read stops early on a success path, so give the level back like the 2434| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2435| | --ctx.depth; 2436| | return; 2437| | } 2438| 2.00k| else { 2439| | // growing 2440| 2.00k| if constexpr (emplace_backable || has_try_emplace_back) { 2441| 200k| while (it < end) { ------------------ | Branch (2441:23): [True: 200k, False: 34] ------------------ 2442| | // Streaming refill point: at start of each iteration, ensure buffer has data 2443| | if constexpr (has_streaming_state) { 2444| | if (ctx.stream.enabled()) { 2445| | const size_t consumed = static_cast(it - ctx.stream.data()); 2446| | const size_t remaining = ctx.stream.size() - consumed; 2447| | // Refill when less than half of buffer remains to ensure space for next element 2448| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2449| | const char* new_it; 2450| | const char* new_end; 2451| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2452| | it = new_it; 2453| | end = new_end; 2454| | if (it >= end && ctx.stream.at_eof()) { 2455| | break; // No more data, exit loop normally 2456| | } 2457| | } 2458| | } 2459| | } 2460| | 2461| | if constexpr (has_try_emplace_back) { 2462| | if (value.try_emplace_back()) 2463| | parse::op()>(value.back(), ctx, it, end); 2464| | else 2465| | ctx.error = error_code::exceeded_static_array_size; 2466| | } 2467| 200k| else { 2468| 200k| parse::op()>(value.emplace_back(), ctx, it, end); 2469| 200k| } 2470| | 2471| 200k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2471:23): [True: 1.60k, False: 198k] ------------------ 2472| 1.60k| return; 2473| | 2474| | // Streaming refill point: after parsing each element, refill if buffer is low 2475| | if constexpr (has_streaming_state) { 2476| | if (ctx.stream.enabled()) { 2477| | const size_t consumed = static_cast(it - ctx.stream.data()); 2478| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2479| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2480| | const char* new_it; 2481| | const char* new_end; 2482| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2483| | it = new_it; 2484| | end = new_end; 2485| | if (it >= end && ctx.stream.at_eof()) { 2486| | ctx.error = error_code::unexpected_end; 2487| | return; 2488| | } 2489| | } 2490| | } 2491| | } 2492| | 2493| 198k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2493:23): [True: 19, False: 198k] ------------------ 2494| 19| return; 2495| 19| } 2496| 198k| if (*it == ',') [[likely]] { ------------------ | Branch (2496:23): [True: 198k, False: 299] ------------------ 2497| 198k| ++it; 2498| | 2499| 198k| if constexpr (!Opts.minified && !Opts.comments) { 2500| 198k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2500:29): [True: 174k, False: 23.5k] | Branch (2500:40): [True: 174k, False: 318] ------------------ 2501| 174k| skip_matching_ws(ws_start, it, ws_size); 2502| 174k| } 2503| 198k| } 2504| | 2505| 198k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2505:26): [True: 54, False: 198k] ------------------ 2506| 54| return; 2507| 54| } 2508| 198k| } 2509| 299| else if (*it == ']') { ------------------ | Branch (2509:28): [True: 67, False: 232] ------------------ 2510| 67| --ctx.depth; 2511| 67| ++it; 2512| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2513| | value.shrink_to_fit(); 2514| | } 2515| 67| return; 2516| 67| } 2517| 232| else [[unlikely]] { 2518| 232| ctx.error = error_code::expected_bracket; 2519| 232| return; 2520| 232| } 2521| 198k| } 2522| | 2523| | // A valid array always returns from inside the loop upon reaching ']'. 2524| | // For a null-terminated buffer the loop can only exit here by falling 2525| | // through when `it` reaches the terminator without a closing bracket, 2526| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2527| | // Non-null-terminated buffers surface this through skip_ws/depth 2528| | // tracking (or the streaming refill break), so this guard is limited 2529| | // to the null-terminated case. 2530| | if constexpr (Opts.null_terminated) { 2531| | ctx.error = error_code::unexpected_end; 2532| | } 2533| | } 2534| | else { 2535| | ctx.error = error_code::exceeded_static_array_size; 2536| | } 2537| 2.00k| } 2538| 2.00k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEETkNS_10is_contextERNS_7contextERPKcSN_EEvOT0_OT1_OT2_T3_: 49| 13.1k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.1k| else { 60| 13.1k| using V = std::remove_cvref_t; 61| 13.1k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.1k| end); 63| 13.1k| } 64| 13.1k| } _ZN3glz4fromILj10ENSt3__13mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiNS1_4lessIS8_EENS6_INS1_4pairIKS8_iEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETnNS_14string_literalEXtlNSJ_ILm1EEEEERSF_TkNS_10is_contextERNS_7contextERPKcSP_EEvOT1_OT2_OT3_T4_: 3085| 13.1k| { 3086| 13.1k| static constexpr auto num_members = reflect::size; 3087| | 3088| 13.1k| static constexpr auto Opts = opening_handled_off()>(); 3089| 13.1k| if constexpr (!check_opening_handled(Options)) { 3090| 13.1k| if constexpr (!check_ws_handled(Options)) { 3091| 13.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3091:20): [True: 34, False: 13.1k] ------------------ 3092| 34| return; 3093| 34| } 3094| 13.1k| } 3095| 13.1k| if (match_invalid_end<'{', Opts>(ctx, it, end)) { ------------------ | Branch (3095:17): [True: 5.10k, False: 8.08k] ------------------ 3096| 5.10k| return; 3097| 5.10k| } 3098| 8.08k| if constexpr (not Opts.null_terminated) { 3099| 8.08k| if (it == end) [[unlikely]] { ------------------ | Branch (3099:20): [True: 0, False: 8.08k] ------------------ 3100| 0| ctx.error = error_code::unexpected_end; 3101| 0| return; 3102| 0| } 3103| 8.08k| } 3104| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 3105| | // released at each syntactic close below 3106| 8.08k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (3106:17): [True: 0, False: 8.08k] ------------------ 3107| 0| return; 3108| 0| } 3109| 8.08k| } 3110| 8.08k| const auto ws_start = it; 3111| 13.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3111:14): [True: 27, False: 13.1k] ------------------ 3112| 27| return; 3113| 27| } 3114| 13.1k| const size_t ws_size = size_t(it - ws_start); 3115| | 3116| | if constexpr ((glaze_object_t || reflectable) && num_members == 0 && Opts.error_on_unknown_keys) { 3117| | if constexpr (not tag.sv().empty()) { 3118| | if (*it == '"') { 3119| | ++it; 3120| | if constexpr (not Opts.null_terminated) { 3121| | if (it == end) [[unlikely]] { 3122| | ctx.error = error_code::unexpected_end; 3123| | return; 3124| | } 3125| | } 3126| | 3127| | const auto start = it; 3128| | skip_string_view(ctx, it, end); 3129| | if (bool(ctx.error)) [[unlikely]] 3130| | return; 3131| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3132| | return; 3133| | const sv key{start, size_t(it - start)}; 3134| | ++it; 3135| | if constexpr (not Opts.null_terminated) { 3136| | if (it == end) [[unlikely]] { 3137| | ctx.error = error_code::unexpected_end; 3138| | return; 3139| | } 3140| | } 3141| | 3142| | if (key == tag.sv()) { 3143| | if (parse_ws_colon(ctx, it, end)) { 3144| | return; 3145| | } 3146| | 3147| | parse::handle_unknown(key, value, ctx, it, end); 3148| | if (bool(ctx.error)) [[unlikely]] 3149| | return; 3150| | 3151| | if (skip_ws(ctx, it, end)) { 3152| | return; 3153| | } 3154| | } 3155| | else { 3156| | ctx.error = error_code::unknown_key; 3157| | return; 3158| | } 3159| | } 3160| | } 3161| | 3162| | if (*it == '}') [[likely]] { 3163| | --ctx.depth; 3164| | if constexpr (glaze_object_t || reflectable) { 3165| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3166| | auto wrapper = self_constraint_v(value); 3167| | from::template op()>(wrapper, ctx, it, end); 3168| | if (bool(ctx.error)) { 3169| | return; 3170| | } 3171| | } 3172| | } 3173| | ++it; 3174| | if constexpr (not Opts.null_terminated) { 3175| | if (it == end) { 3176| | ctx.error = error_code::end_reached; 3177| | return; 3178| | } 3179| | } 3180| | if constexpr (Opts.partial_read) { 3181| | ctx.error = error_code::partial_read_complete; 3182| | } 3183| | return; 3184| | } 3185| | ctx.error = error_code::unknown_key; 3186| | return; 3187| | } 3188| 13.1k| else { 3189| 13.1k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| 13.1k| if constexpr ((glaze_object_t || reflectable) && 3191| 13.1k| (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| 13.1k| return bit_array{}; 3193| 13.1k| } 3194| 13.1k| else { 3195| 13.1k| return nullptr; 3196| 13.1k| } 3197| 13.1k| }(); 3198| | 3199| 13.1k| size_t read_count{}; // for partial_read 3200| | 3201| 13.1k| bool first = true; 3202| 60.1k| while (true) { ------------------ | Branch (3202:20): [True: 47.5k, Folded] ------------------ 3203| | if constexpr ((glaze_object_t || reflectable) && Opts.partial_read) { 3204| | static constexpr bit_array all_fields = [] { 3205| | bit_array arr{}; 3206| | for (size_t i = 0; i < num_members; ++i) { 3207| | arr[i] = true; 3208| | } 3209| | return arr; 3210| | }(); 3211| | 3212| | if ((all_fields & fields) == all_fields) { 3213| | ctx.error = error_code::partial_read_complete; 3214| | --ctx.depth; // as above: an early success still closes this level 3215| | return; 3216| | } 3217| | } 3218| | 3219| | // Streaming refill point: at start of each iteration, ensure buffer has data 3220| | if constexpr (has_streaming_state) { 3221| | if (ctx.stream.enabled()) { 3222| | const size_t consumed = static_cast(it - ctx.stream.data()); 3223| | const size_t remaining = ctx.stream.size() - consumed; 3224| | // Refill when less than half of buffer remains to ensure space for next key-value pair 3225| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 3226| | const char* new_it; 3227| | const char* new_end; 3228| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3229| | it = new_it; 3230| | end = new_end; 3231| | if (it >= end && ctx.stream.at_eof()) { 3232| | ctx.error = error_code::unexpected_end; 3233| | return; 3234| | } 3235| | } 3236| | } 3237| | } 3238| | 3239| 47.5k| if (*it == '}') { ------------------ | Branch (3239:20): [True: 40, False: 47.4k] ------------------ 3240| 40| --ctx.depth; 3241| | if constexpr ((glaze_object_t || reflectable) && Opts.error_on_missing_keys) { 3242| | constexpr auto req_fields = required_fields(); 3243| | if ((req_fields & fields) != req_fields) { 3244| | for (size_t i = 0; i < num_members; ++i) { 3245| | if (not fields[i] && req_fields[i]) { 3246| | ctx.custom_error_message = reflect::keys[i]; 3247| | // We just return the first missing key in order to avoid heap allocations 3248| | break; 3249| | } 3250| | } 3251| | 3252| | ctx.error = error_code::missing_key; 3253| | return; 3254| | } 3255| | } 3256| | if constexpr (glaze_object_t || reflectable) { 3257| | if constexpr (has_self_constraint_v && !check_skip_self_constraint(Opts)) { 3258| | auto wrapper = self_constraint_v(value); 3259| | from::template op()>(wrapper, ctx, it, end); 3260| | if (bool(ctx.error)) { 3261| | return; 3262| | } 3263| | } 3264| | } 3265| 40| ++it; // Increment after checking for missing keys so errors are within buffer bounds 3266| 40| if constexpr (not Opts.null_terminated) { 3267| 40| if (it == end) { ------------------ | Branch (3267:26): [True: 20, False: 20] ------------------ 3268| 20| ctx.error = error_code::end_reached; 3269| 20| return; 3270| 20| } 3271| 40| } 3272| 20| return; 3273| 40| } 3274| 47.4k| else if (first) { ------------------ | Branch (3274:25): [True: 7.98k, False: 39.4k] ------------------ 3275| 7.98k| first = false; 3276| 7.98k| } 3277| 39.4k| else { 3278| 39.4k| if (match_invalid_end<',', Opts>(ctx, it, end)) { ------------------ | Branch (3278:23): [True: 353, False: 39.1k] ------------------ 3279| 353| return; 3280| 353| } 3281| 39.1k| if constexpr (not Opts.null_terminated) { 3282| 39.1k| if (it == end) [[unlikely]] { ------------------ | Branch (3282:26): [True: 0, False: 39.1k] ------------------ 3283| 0| ctx.error = error_code::unexpected_end; 3284| 0| return; 3285| 0| } 3286| 39.1k| } 3287| | 3288| | if constexpr ((not Opts.minified) && (num_members > 1 || not Opts.error_on_unknown_keys) && 3289| | (!Opts.comments)) { 3290| | if (ws_size && ws_size < size_t(end - it)) { 3291| | skip_matching_ws(ws_start, it, ws_size); 3292| | } 3293| | } 3294| | 3295| 39.1k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3295:23): [True: 44, False: 39.0k] ------------------ 3296| 44| return; 3297| 44| } 3298| 39.1k| } 3299| | 3300| 47.0k| constexpr auto reflection_type = glaze_object_t || reflectable; ------------------ | Branch (3300:49): [Folded, False: 0] | Branch (3300:70): [Folded, False: 0] ------------------ 3301| | 3302| | if constexpr (reflection_type && (num_members == 0)) { 3303| | if constexpr (Opts.error_on_unknown_keys) { 3304| | static_assert(false_v, "This should be unreachable"); 3305| | } 3306| | else { 3307| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 3308| | return; 3309| | } 3310| | 3311| | // parsing to an empty object, but at this point the JSON presents keys 3312| | 3313| | // Unknown key handler does not unescape keys. Unknown escaped keys are 3314| | // handled by the user. 3315| | 3316| | const auto start = it; 3317| | skip_string_view(ctx, it, end); 3318| | if (bool(ctx.error)) [[unlikely]] 3319| | return; 3320| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3321| | return; 3322| | const sv key{start, size_t(it - start)}; 3323| | ++it; 3324| | if constexpr (not Opts.null_terminated) { 3325| | if (it == end) [[unlikely]] { 3326| | ctx.error = error_code::unexpected_end; 3327| | return; 3328| | } 3329| | } 3330| | 3331| | if (parse_ws_colon(ctx, it, end)) { 3332| | return; 3333| | } 3334| | 3335| | // Check if this key is the variant tag that should be skipped 3336| | if constexpr (not tag.sv().empty()) { 3337| | if (key == tag.sv()) { 3338| | // Skip the tag value 3339| | skip_value::op(ctx, it, end); 3340| | if (bool(ctx.error)) [[unlikely]] 3341| | return; 3342| | if (skip_ws(ctx, it, end)) { 3343| | return; 3344| | } 3345| | continue; 3346| | } 3347| | } 3348| | 3349| | parse::handle_unknown(key, value, ctx, it, end); 3350| | if (bool(ctx.error)) [[unlikely]] 3351| | return; 3352| | if constexpr (not Opts.null_terminated) { 3353| | if (it == end) [[unlikely]] { 3354| | ctx.error = error_code::unexpected_end; 3355| | return; 3356| | } 3357| | } 3358| | if (skip_ws(ctx, it, end)) { 3359| | return; 3360| | } 3361| | } 3362| | } 3363| | else if constexpr (reflection_type) { 3364| | static_assert(bool(hash_info.type)); 3365| | 3366| | if (*it != '"') [[unlikely]] { 3367| | ctx.error = error_code::expected_quote; 3368| | return; 3369| | } 3370| | ++it; 3371| | if constexpr (not Opts.null_terminated) { 3372| | if (it == end) [[unlikely]] { 3373| | ctx.error = error_code::unexpected_end; 3374| | return; 3375| | } 3376| | } 3377| | 3378| | if constexpr (not tag.sv().empty() && not contains_tag()) { 3379| | // For tagged variants we first check to see if the key matches the tag 3380| | // We only need to do this if the tag is not part of the keys 3381| | 3382| | const auto start = it; 3383| | skip_string_view(ctx, it, end); 3384| | if (bool(ctx.error)) [[unlikely]] 3385| | return; 3386| | if (validate_utf8_span(ctx, start, it)) [[unlikely]] 3387| | return; 3388| | const sv key{start, size_t(it - start)}; 3389| | ++it; 3390| | if constexpr (not Opts.null_terminated) { 3391| | if (it == end) [[unlikely]] { 3392| | ctx.error = error_code::unexpected_end; 3393| | return; 3394| | } 3395| | } 3396| | 3397| | if (key == tag.sv()) { 3398| | if (parse_ws_colon(ctx, it, end)) { 3399| | return; 3400| | } 3401| | 3402| | parse::handle_unknown(key, value, ctx, it, end); 3403| | if (bool(ctx.error)) [[unlikely]] 3404| | return; 3405| | 3406| | if (skip_ws(ctx, it, end)) { 3407| | return; 3408| | } 3409| | continue; 3410| | } 3411| | else { 3412| | it = start; // reset the iterator 3413| | } 3414| | } 3415| | 3416| | if constexpr (Opts.error_on_missing_keys || Opts.partial_read) { 3417| | size_t index = num_members; 3418| | parse_and_invoke(value, ctx, it, end, index); 3419| | if (bool(ctx.error)) [[unlikely]] 3420| | return; 3421| | if (index < num_members) { 3422| | fields[index] = true; 3423| | } 3424| | } 3425| | else { 3426| | parse_and_invoke(value, ctx, it, end); 3427| | if (bool(ctx.error)) [[unlikely]] 3428| | return; 3429| | } 3430| | } 3431| 47.0k| else { 3432| | // For types like std::map, std::unordered_map 3433| | 3434| 47.0k| auto reading = [&](auto&& key) { 3435| 47.0k| if constexpr (Opts.partial_read) { 3436| 47.0k| if (auto element = value.find(key); element != value.end()) { 3437| 47.0k| ++read_count; 3438| 47.0k| parse::op()>(element->second, ctx, it, end); 3439| 47.0k| } 3440| 47.0k| else { 3441| 47.0k| skip_value::op(ctx, it, end); 3442| 47.0k| } 3443| 47.0k| } 3444| 47.0k| else { 3445| 47.0k| parse::op()>(value[key], ctx, it, end); 3446| 47.0k| } 3447| 47.0k| }; 3448| | 3449| | // using Key = std::conditional_t, sv, typename T::key_type>; 3450| 47.0k| using Key = typename T::key_type; 3451| 47.0k| if constexpr (std::is_same_v) { 3452| 47.0k| ctx.scratch.clear(); 3453| 47.0k| parse::op(ctx.scratch, ctx, it, end); 3454| 47.0k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3454:26): [True: 994, False: 46.0k] ------------------ 3455| 994| return; 3456| | 3457| 46.0k| if (parse_ws_colon(ctx, it, end)) { ------------------ | Branch (3457:26): [True: 594, False: 45.4k] ------------------ 3458| 594| return; 3459| 594| } 3460| | 3461| 45.4k| reading(ctx.scratch); 3462| | if constexpr (Opts.partial_read) { 3463| | if (read_count == value.size()) { 3464| | return; 3465| | } 3466| | } 3467| 45.4k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (3467:26): [True: 5.94k, False: 39.5k] ------------------ 3468| 5.94k| return; 3469| | } 3470| | else if constexpr (str_t) { 3471| | Key key; 3472| | parse::op(key, ctx, it, end); 3473| | if (bool(ctx.error)) [[unlikely]] 3474| | return; 3475| | 3476| | if (parse_ws_colon(ctx, it, end)) { 3477| | return; 3478| | } 3479| | 3480| | reading(key); 3481| | if constexpr (Opts.partial_read) { 3482| | if (read_count == value.size()) { 3483| | return; 3484| | } 3485| | } 3486| | if (bool(ctx.error)) [[unlikely]] 3487| | return; 3488| | } 3489| | else { 3490| | Key key_value{}; 3491| | if constexpr (is_named_enum || mimics_str_t) { 3492| | parse::op(key_value, ctx, it, end); 3493| | } 3494| | else if constexpr (std::is_arithmetic_v) { 3495| | // prefer over quoted_t below to avoid double parsing of quoted_t 3496| | parse::op>(key_value, ctx, it, end); 3497| | } 3498| | else { 3499| | parse::op>(quoted_t{key_value}, ctx, it, end); 3500| | } 3501| | if (bool(ctx.error)) [[unlikely]] 3502| | return; 3503| | 3504| | if (parse_ws_colon(ctx, it, end)) { 3505| | return; 3506| | } 3507| | 3508| | reading(key_value); 3509| | if constexpr (Opts.partial_read) { 3510| | if (read_count == value.size()) { 3511| | return; 3512| | } 3513| | } 3514| | if (bool(ctx.error)) [[unlikely]] 3515| | return; 3516| | } 3517| 47.0k| } 3518| | 3519| | // Streaming refill point: after parsing each key-value pair, refill if buffer is low 3520| | if constexpr (has_streaming_state) { 3521| | if (ctx.stream.enabled()) { 3522| | const size_t consumed = static_cast(it - ctx.stream.data()); 3523| | // Refill when less than 25% of buffer remains to ensure enough space for next element 3524| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 3525| | const char* new_it; 3526| | const char* new_end; 3527| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 3528| | it = new_it; 3529| | end = new_end; 3530| | if (it >= end && ctx.stream.at_eof()) { 3531| | ctx.error = error_code::unexpected_end; 3532| | return; 3533| | } 3534| | } 3535| | } 3536| | } 3537| | 3538| 47.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (3538:20): [True: 55, False: 47.0k] ------------------ 3539| 55| return; 3540| 55| } 3541| 47.0k| } 3542| 13.1k| } 3543| 13.1k| } _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: 3189| 8.02k| decltype(auto) fields = [&]() -> decltype(auto) { 3190| | if constexpr ((glaze_object_t || reflectable) && 3191| | (Opts.error_on_missing_keys || Opts.partial_read)) { 3192| | return bit_array{}; 3193| | } 3194| 8.02k| else { 3195| 8.02k| return nullptr; 3196| 8.02k| } 3197| 8.02k| }(); _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_: 3434| 45.4k| auto reading = [&](auto&& key) { 3435| | if constexpr (Opts.partial_read) { 3436| | if (auto element = value.find(key); element != value.end()) { 3437| | ++read_count; 3438| | parse::op()>(element->second, ctx, it, end); 3439| | } 3440| | else { 3441| | skip_value::op(ctx, it, end); 3442| | } 3443| | } 3444| 45.4k| else { 3445| 45.4k| parse::op()>(value[key], ctx, it, end); 3446| 45.4k| } 3447| 45.4k| }; _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEETkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 49| 13.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.0k| else { 60| 13.0k| using V = std::remove_cvref_t; 61| 13.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.0k| end); 63| 13.0k| } 64| 13.0k| } _ZN3glz4fromILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERPKcSB_EEvOT0_OT1_OT2_T3_: 5098| 13.0k| { 5099| 13.0k| constexpr auto Opts = ws_handled_off(); 5100| 13.0k| if constexpr (!check_ws_handled(Options)) { 5101| 13.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (5101:17): [True: 33, False: 13.0k] ------------------ 5102| 33| return; 5103| 33| } 5104| 13.0k| } 5105| | 5106| 13.0k| if (*it == 'n') { ------------------ | Branch (5106:14): [True: 34, False: 13.0k] ------------------ 5107| 34| ++it; 5108| 34| if constexpr (not Opts.null_terminated) { 5109| 34| if (it == end) [[unlikely]] { ------------------ | Branch (5109:20): [True: 3, False: 31] ------------------ 5110| 3| ctx.error = error_code::unexpected_end; 5111| 3| return; 5112| 3| } 5113| 34| } 5114| 31| match<"ull", Opts>(ctx, it, end); 5115| 34| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (5115:17): [True: 28, False: 6] ------------------ 5116| 28| return; 5117| 6| if constexpr (requires { value.reset(); }) { 5118| 6| value.reset(); 5119| 6| } 5120| 6| } 5121| 13.0k| else { 5122| 13.0k| if constexpr (nullable_value_t) { 5123| 13.0k| if (not value.has_value()) { ------------------ | Branch (5123:20): [True: 12.9k, False: 33] ------------------ 5124| | if constexpr (constructible) { 5125| | value = meta_construct_v(); 5126| | } 5127| 12.9k| else if constexpr (requires { value.emplace(); }) { 5128| 12.9k| value.emplace(); 5129| | } 5130| | else { 5131| | static_assert(false_v, 5132| | "Your nullable type must have `emplace()` or be glz::meta constructible, or " 5133| | "create a custom glz::from specialization"); 5134| | } 5135| 12.9k| } 5136| 13.0k| parse::op(value.value(), ctx, it, end); 5137| | } 5138| | else { 5139| | if (!value) { 5140| | if (!nullable_emplace(value, ctx)) { 5141| | return; 5142| | } 5143| | } 5144| | parse::op(*value, ctx, it, end); 5145| | } 5146| 13.0k| } 5147| 13.0k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN9repe_fuzz6amountEEEETkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 49| 13.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.0k| else { 60| 13.0k| using V = std::remove_cvref_t; 61| 13.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.0k| end); 63| 13.0k| } 64| 13.0k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4093| 13.0k| { 4094| | if constexpr (tagging == variant_tagging_kind::adjacent) { 4095| | read_adjacent(value, ctx, it, end); 4096| | } 4097| 13.0k| else { 4098| 13.0k| read_deduced(value, ctx, it, end); 4099| 13.0k| } 4100| 13.0k| } _ZN3glz4fromILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE12read_deducedITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSB_TkNS_10is_contextERNS_7contextERPKcSJ_EEvOT0_OT1_OT2_T3_: 4104| 13.0k| { 4105| 13.0k| constexpr auto Opts = ws_handled_off(); 4106| 13.0k| if constexpr (variant_is_auto_deducible()) { 4107| 13.0k| if constexpr (not check_ws_handled(Options)) { 4108| 13.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (4108:20): [True: 33, False: 13.0k] ------------------ 4109| 33| return; 4110| 33| } 4111| 13.0k| } 4112| | 4113| 13.0k| switch (*it) { 4114| 220| case '\0': ------------------ | Branch (4114:13): [True: 220, False: 12.8k] ------------------ 4115| 220| ctx.error = error_code::unexpected_end; 4116| 220| return; 4117| 7.92k| case '{': { ------------------ | Branch (4117:13): [True: 7.92k, False: 5.14k] ------------------ 4118| | // This branch consumes the brace itself and hands the object to a reader with 4119| | // `opening_handled`, which therefore does not count the level -- but does release it at 4120| | // the closing brace. So the level is taken here, in both buffer modes, and paid back by 4121| | // the reader below. 4122| 7.92k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (4122:20): [True: 0, False: 7.92k] ------------------ 4123| 0| return; 4124| 0| } 4125| | 4126| 7.92k| ++it; 4127| 7.92k| if constexpr (not Opts.null_terminated) { 4128| 7.92k| if (it == end) [[unlikely]] { ------------------ | Branch (4128:23): [True: 9, False: 7.91k] ------------------ 4129| 9| ctx.error = error_code::unexpected_end; 4130| 9| return; 4131| 9| } 4132| 7.92k| } 4133| 7.91k| using type_counts = variant_type_count; 4134| 7.92k| constexpr auto n_object_candidates = variant_object_candidate_count_v; 4135| | if constexpr (n_object_candidates < 1) { 4136| | ctx.error = error_code::no_matching_variant_type; 4137| | return; 4138| | } 4139| 7.92k| else if constexpr (n_object_candidates == 1 && tag_v.empty()) { 4140| 7.92k| constexpr auto first_idx = variant_first_object_candidate_v; 4141| 7.92k| using V = std::variant_alternative_t; 4142| 7.92k| if (!std::holds_alternative(value)) value = V{}; ------------------ | Branch (4142:23): [True: 7.91k, False: 9] ------------------ 4143| 7.92k| parse::op()>(std::get(value), ctx, it, end); 4144| 7.92k| return; 4145| | } 4146| | else { 4147| | auto possible_types = bit_array>{}.flip(); 4148| | static constexpr auto& deduction_bits = variant_deduction_bits; 4149| | static constexpr size_t deduction_key_count = variant_deduction_key_count; 4150| | static constexpr auto tag_literal = string_literal_from_view.size()>(tag_v); 4151| | 4152| | // Track if we've encountered a tag and what value it had 4153| | std::optional tag_specified_index{}; 4154| | 4155| | if (skip_ws(ctx, it, end)) { 4156| | return; 4157| | } 4158| | auto start = it; 4159| | bool first_key = true; 4160| | // Parse bifurcation for tagged variants: 4161| | // 4162| | // Without this optimization, tagged variant parsing always uses two passes: 4163| | // 1. Scan all keys to find the tag (e.g. "type"), skipping values 4164| | // 2. Reset `it = start` and re-parse the entire object into the resolved type 4165| | // 4166| | // When the tag is the first key, the second pass redundantly re-reads every 4167| | // field that follows it. This lambda avoids that: if the tag was the first key, 4168| | // it advances past the trailing comma so the object parser picks up at the 4169| | // second field. If the tag was found later, it falls back to the full re-parse. 4170| | // 4171| | // One exception: if the tag name is also a field on the resolved struct 4172| | // (contains_tag), we must re-parse regardless so the value is stored in 4173| | // the struct field. This override is applied inside each std::visit lambda. 4174| | auto position_after_tag = [&] { 4175| | if (first_key) { 4176| | if (*it == ',') ++it; // skip comma; handles tag-only objects where *it == '}' 4177| | } 4178| | else { 4179| | it = start; // tag was not the first key, re-parse from the beginning 4180| | } 4181| | }; 4182| | while (*it != '}') { 4183| | if (it != start) { 4184| | first_key = false; 4185| | if (match_invalid_end<',', Opts>(ctx, it, end)) { 4186| | return; 4187| | } 4188| | } 4189| | 4190| | if (skip_ws(ctx, it, end)) { 4191| | return; 4192| | } 4193| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4194| | return; 4195| | } 4196| | 4197| | auto* key_start = it; 4198| | skip_string_view(ctx, it, end); 4199| | if (bool(ctx.error)) [[unlikely]] 4200| | return; 4201| | if (validate_utf8_span(ctx, key_start, it)) [[unlikely]] 4202| | return; 4203| | const sv key = {key_start, size_t(it - key_start)}; 4204| | 4205| | if (match_invalid_end<'"', Opts>(ctx, it, end)) { 4206| | return; 4207| | } 4208| | 4209| | if constexpr (deduction_key_count > 0) { 4210| | // We first check if a tag is defined and see if the key matches the tag 4211| | if constexpr (not tag_v.empty()) { 4212| | if (key == tag_v) { 4213| | if (parse_ws_colon(ctx, it, end)) { 4214| | return; 4215| | } 4216| | 4217| | using id_type = std::decay_t[0])>; 4218| | 4219| | std::conditional_t, id_type, sv> type_id{}; 4220| | if constexpr (std::integral) { 4221| | from::template op()>(type_id, ctx, it, end); 4222| | } 4223| | else { 4224| | from::template op()>(type_id, ctx, it, end); 4225| | } 4226| | if (bool(ctx.error)) [[unlikely]] 4227| | return; 4228| | if (skip_ws(ctx, it, end)) { 4229| | return; 4230| | } 4231| | if (!(*it == ',' || *it == '}')) [[unlikely]] { 4232| | ctx.error = error_code::syntax_error; 4233| | return; 4234| | } 4235| | 4236| | size_t type_index; 4237| | if constexpr (std::integral) { 4238| | type_index = variant_id_to_index::op(type_id); 4239| | } 4240| | else { 4241| | type_index = variant_id_to_index::op( 4242| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4243| | } 4244| | if (type_index < ids_v.size()) [[likely]] { 4245| | // Check if the deduced types include the tag-specified type 4246| | // If not, the tag doesn't match the fields 4247| | // We're already inside if constexpr (deduction_registry.size()), so we know deduction 4248| | // is happening. At this point, possible_types has been narrowed by field deduction. 4249| | // Check if the tag-specified type is still possible 4250| | const bool type_is_possible = possible_types[type_index]; 4251| | if (!type_is_possible) { 4252| | // Tag specifies a type that doesn't match the fields seen so far 4253| | ctx.error = error_code::no_matching_variant_type; 4254| | return; 4255| | } 4256| | 4257| | position_after_tag(); 4258| | tag_specified_index = type_index; // Store the tag-specified type 4259| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4260| | std::visit( 4261| | [&](auto&& v) { 4262| | using V = std::decay_t; 4263| | constexpr bool is_object = 4264| | (glaze_object_t || reflectable) && not custom_read; 4265| | if constexpr (variant_unit_alternative) { 4266| | // A unit alternative carries no data; its object holds only the 4267| | // discriminator. Consume that body through an empty reflected object so 4268| | // unknown-key policy and terminator handling match every other alternative. 4269| | detail::variant_unit_body unit_body{}; 4270| | from::template op(), 4271| | tag_literal>(unit_body, 4272| | ctx, it, end); 4273| | } 4274| | else if constexpr (is_object) { 4275| | if constexpr (contains_tag()) { 4276| | it = start; // tag is a struct field, must re-parse 4277| | } 4278| | from::template op(), tag_literal>(v, ctx, it, 4279| | end); 4280| | } 4281| | else if constexpr (is_memory_object) { 4282| | if (!v) { 4283| | if constexpr (is_specialization_v) { 4284| | if constexpr (requires { v.emplace(); }) { 4285| | v.emplace(); 4286| | } 4287| | else { 4288| | v = typename V::value_type{}; 4289| | } 4290| | } 4291| | else if constexpr (is_specialization_v) 4292| | v = std::make_unique(); 4293| | else if constexpr (is_specialization_v) 4294| | v = std::make_shared(); 4295| | else if constexpr (constructible) { 4296| | v = meta_construct_v(); 4297| | } 4298| | else if constexpr (std::is_pointer_v && 4299| | can_allocate_raw_pointer>) { 4301| | if (!try_allocate_raw_pointer(v, ctx)) { 4302| | return; 4303| | } 4304| | } 4305| | else { 4306| | ctx.error = error_code::invalid_nullable_read; 4307| | return; 4308| | // Cannot read into unset nullable that is not std::optional, 4309| | // std::unique_ptr, or std::shared_ptr 4310| | } 4311| | } 4312| | if constexpr (contains_tag, tag_literal>()) { 4313| | it = start; // tag is a struct field, must re-parse 4314| | } 4315| | from>::template op(), tag_literal>( 4316| | *v, ctx, it, end); 4317| | } 4318| | else if constexpr (custom_read) { 4319| | // Custom handlers parse the remaining body themselves and do not 4320| | // accept the tag template parameter; the tag was already consumed. 4321| | // This only works when the tag was the first key. If it came later, 4322| | // we were reset to the object start and the custom handler would 4323| | // absorb the tag, so error rather than corrupt the value. 4324| | if (it == start) { 4325| | ctx.error = error_code::feature_not_supported; 4326| | ctx.custom_error_message = 4327| | "the tag must be the first key for a custom variant alternative"; 4328| | return; 4329| | } 4330| | from::template op()>(v, ctx, it, end); 4331| | } 4332| | }, 4333| | value); 4334| | 4335| | return; // we've decoded our target type 4336| | } 4337| | else [[unlikely]] { 4338| | // Check if we have a default type (ids array shorter than variant) 4339| | constexpr auto ids_size = ids_v.size(); 4340| | constexpr auto variant_size = std::variant_size_v; 4341| | if constexpr (ids_size < variant_size) { 4342| | // Use the first unlabeled type as the default 4343| | const auto default_type_index = ids_size; 4344| | 4345| | position_after_tag(); 4346| | tag_specified_index = default_type_index; // Store the default type index 4347| | if (value.index() != default_type_index) 4348| | emplace_runtime_variant(value, default_type_index); 4349| | std::visit( 4350| | [&](auto&& v) { 4351| | using V = std::decay_t; 4352| | constexpr bool is_object = 4353| | (glaze_object_t || reflectable) && not custom_read; 4354| | if constexpr (variant_unit_alternative) { 4355| | // A unit alternative carries no data; its object holds only the 4356| | // discriminator. Consume that body through an empty reflected object so 4357| | // unknown-key policy and terminator handling match every other 4358| | // alternative. 4359| | detail::variant_unit_body unit_body{}; 4360| | from::template op(), 4361| | tag_literal>( 4362| | unit_body, ctx, it, end); 4363| | } 4364| | else if constexpr (is_object) { 4365| | if constexpr (contains_tag()) { 4366| | it = start; // tag is a struct field, must re-parse 4367| | } 4368| | from::template op()>(v, ctx, it, end); 4369| | } 4370| | else if constexpr (is_memory_object) { 4371| | if (!v) { 4372| | if constexpr (is_specialization_v) { 4373| | if constexpr (requires { v.emplace(); }) { 4374| | v.emplace(); 4375| | } 4376| | else { 4377| | v = typename V::value_type{}; 4378| | } 4379| | } 4380| | else if constexpr (is_specialization_v) 4381| | v = std::make_unique(); 4382| | else if constexpr (is_specialization_v) 4383| | v = std::make_shared(); 4384| | else if constexpr (constructible) { 4385| | v = meta_construct_v(); 4386| | } 4387| | else if constexpr (std::is_pointer_v && 4388| | can_allocate_raw_pointer< 4389| | Opts, std::decay_t>) { 4390| | if (!try_allocate_raw_pointer(v, ctx)) { 4391| | return; 4392| | } 4393| | } 4394| | else { 4395| | ctx.error = error_code::invalid_nullable_read; 4396| | return; 4397| | } 4398| | } 4399| | if constexpr (contains_tag, tag_literal>()) { 4400| | it = start; // tag is a struct field, must re-parse 4401| | } 4402| | from>::template op()>(*v, ctx, 4403| | it, end); 4404| | } 4405| | else if constexpr (custom_read) { 4406| | // Custom handlers parse the remaining body themselves; this only 4407| | // works when the tag was the first key (see above). If it came 4408| | // later we were reset to the object start, so error rather than 4409| | // let the custom handler absorb the tag. 4410| | if (it == start) { 4411| | ctx.error = error_code::feature_not_supported; 4412| | ctx.custom_error_message = 4413| | "the tag must be the first key for a custom variant alternative"; 4414| | return; 4415| | } 4416| | from::template op()>(v, ctx, it, end); 4417| | } 4418| | }, 4419| | value); 4420| | 4421| | return; 4422| | } 4423| | else { 4424| | ctx.error = error_code::no_matching_variant_type; 4425| | ctx.custom_error_message = variant_ids_string_v; 4426| | return; 4427| | } 4428| | } 4429| | } 4430| | } 4431| | 4432| | // Inline decode_hash lookup for variant deduction 4433| | using deduction_keys_t = keys_wrapper>; 4434| | constexpr auto& DeductionHashInfo = hash_info; 4435| | const auto deduction_index = 4436| | decode_hash_with_size::op( 4437| | key.data(), key.data() + key.size(), key.size()); 4438| | if (deduction_index < deduction_key_count && variant_deduction_keys[deduction_index] == key) 4439| | [[likely]] { 4440| | possible_types &= deduction_bits[deduction_index]; 4441| | } 4442| | else if constexpr (Opts.error_on_unknown_keys) { 4443| | ctx.error = error_code::unknown_key; 4444| | return; 4445| | } 4446| | } 4447| | else if constexpr (not tag_v.empty()) { 4448| | // empty object case for variant, if there are no normal elements 4449| | if (key == tag_v) { 4450| | if (parse_ws_colon(ctx, it, end)) { 4451| | return; 4452| | } 4453| | 4454| | std::string_view type_id{}; 4455| | parse::op()>(type_id, ctx, it, end); 4456| | if (bool(ctx.error)) [[unlikely]] 4457| | return; 4458| | if (skip_ws(ctx, it, end)) { 4459| | return; 4460| | } 4461| | 4462| | const auto type_index = variant_id_to_index::op( 4463| | type_id.data(), type_id.data() + type_id.size(), type_id.size()); 4464| | if (type_index < ids_v.size()) [[likely]] { 4465| | position_after_tag(); 4466| | tag_specified_index = type_index; // Store the tag-specified type 4467| | if (value.index() != type_index) emplace_runtime_variant(value, type_index); 4468| | } 4469| | else { 4470| | // Check if we have a default type (ids array shorter than variant) 4471| | constexpr auto ids_size = ids_v.size(); 4472| | constexpr auto variant_size = std::variant_size_v; 4473| | if constexpr (ids_size < variant_size) { 4474| | // Use the first unlabeled type as the default 4475| | position_after_tag(); 4476| | const auto default_index = ids_size; 4477| | tag_specified_index = default_index; // Store the default type index 4478| | if (value.index() != default_index) emplace_runtime_variant(value, default_index); 4479| | } 4480| | else { 4481| | ctx.error = error_code::no_matching_variant_type; 4482| | ctx.custom_error_message = variant_ids_string_v; 4483| | return; 4484| | } 4485| | } 4486| | // Parse the type (handles tag skipping and unknown keys) 4487| | std::visit( 4488| | [&](auto&& v) { 4489| | using V = std::decay_t; 4490| | if constexpr (custom_read) { 4491| | // Custom handlers parse the remaining object body themselves and do not 4492| | // accept the tag template parameter that reflected objects use to skip an 4493| | // interior tag key. That only works when the tag is the first key (it was 4494| | // just consumed). If the tag came after other keys, position_after_tag() 4495| | // reset us to the object start and the custom handler would absorb the tag 4496| | // into its value, so error here rather than corrupt the result. 4497| | if (it == start) { 4498| | ctx.error = error_code::feature_not_supported; 4499| | ctx.custom_error_message = 4500| | "the tag must be the first key for a custom variant alternative"; 4501| | return; 4502| | } 4503| | from::template op()>(v, ctx, it, end); 4504| | } 4505| | else { 4506| | if constexpr (contains_tag()) { 4507| | it = start; // tag is a struct field, must re-parse 4508| | } 4509| | from::template op(), tag_literal>(v, ctx, it, end); 4510| | } 4511| | }, 4512| | value); 4513| | return; 4514| | } 4515| | else if constexpr (Opts.error_on_unknown_keys) { 4516| | ctx.error = error_code::unknown_key; 4517| | return; 4518| | } 4519| | else { 4520| | // Skip unknown key's value (non-tag key in empty variant) 4521| | if (parse_ws_colon(ctx, it, end)) { 4522| | return; 4523| | } 4524| | skip_value::op(ctx, it, end); 4525| | if (bool(ctx.error)) [[unlikely]] 4526| | return; 4527| | if (skip_ws(ctx, it, end)) { 4528| | return; 4529| | } 4530| | continue; // Continue loop to find the tag 4531| | } 4532| | } 4533| | else if constexpr (Opts.error_on_unknown_keys) { 4534| | ctx.error = error_code::unknown_key; 4535| | return; 4536| | } 4537| | 4538| | auto matching_types = possible_types.popcount(); 4539| | if (matching_types == 0) { 4540| | ctx.error = error_code::no_matching_variant_type; 4541| | return; 4542| | } 4543| | // Only short-circuit for variants without tags 4544| | else if constexpr (tag_v.empty()) { 4545| | if (matching_types == 1) { 4546| | it = start; 4547| | const auto type_index = possible_types.countr_zero(); 4548| | 4549| | if (value.index() != static_cast(type_index)) 4550| | emplace_runtime_variant(value, type_index); 4551| | std::visit( 4552| | [&](auto&& v) { 4553| | using V = std::decay_t; 4554| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4555| | if constexpr (variant_unit_alternative) { 4556| | // A unit alternative carries no data; its object holds only the discriminator. 4557| | // Consume that body through an empty reflected object so unknown-key policy and 4558| | // terminator handling match every other alternative. 4559| | detail::variant_unit_body unit_body{}; 4560| | from::template op(), 4561| | tag_literal>(unit_body, ctx, it, 4562| | end); 4563| | } 4564| | else if constexpr (is_object) { 4565| | from::template op(), tag_literal>(v, ctx, it, end); 4566| | } 4567| | else if constexpr (is_memory_object) { 4568| | if (!v) { 4569| | if constexpr (is_specialization_v) { 4570| | if constexpr (requires { v.emplace(); }) { 4571| | v.emplace(); 4572| | } 4573| | else { 4574| | v = typename V::value_type{}; 4575| | } 4576| | } 4577| | else if constexpr (is_specialization_v) 4578| | v = std::make_unique(); 4579| | else if constexpr (is_specialization_v) 4580| | v = std::make_shared(); 4581| | else if constexpr (constructible) { 4582| | v = meta_construct_v(); 4583| | } 4584| | else if constexpr (std::is_pointer_v && 4585| | can_allocate_raw_pointer>) { 4586| | if (!try_allocate_raw_pointer(v, ctx)) { 4587| | return; 4588| | } 4589| | } 4590| | else { 4591| | ctx.error = error_code::invalid_nullable_read; 4592| | return; 4593| | // Cannot read into unset nullable that is not std::optional, 4594| | // std::unique_ptr, or std::shared_ptr 4595| | } 4596| | } 4597| | from>::template op(), tag_literal>( 4598| | *v, ctx, it, end); 4599| | } 4600| | else if constexpr (custom_read) { 4601| | // Custom handlers parse the remaining body themselves. 4602| | from::template op()>(v, ctx, it, end); 4603| | } 4604| | }, 4605| | value); 4606| | 4607| | return; // we've decoded our target type 4608| | } 4609| | } 4610| | // For tagged variants, continue processing to validate tags 4611| | if (parse_ws_colon(ctx, it, end)) { 4612| | return; 4613| | } 4614| | 4615| | skip_value::op(ctx, it, end); 4616| | if (bool(ctx.error)) [[unlikely]] 4617| | return; 4618| | if (skip_ws(ctx, it, end)) { 4619| | return; 4620| | } 4621| | } 4622| | // Only apply ambiguous variant resolution if we have multiple object types 4623| | if constexpr ((type_counts::n_object + type_counts::n_nullable_object) > 1) { 4624| | // After parsing all keys, check if we have multiple matching types 4625| | // If so, choose the one with the fewest fields 4626| | auto final_matching = possible_types.popcount(); 4627| | if (final_matching == 0) { 4628| | ctx.error = error_code::no_matching_variant_type; 4629| | } 4630| | else if (final_matching == 1) { 4631| | // Single type remains after field deduction 4632| | const auto type_index = possible_types.countr_zero(); 4633| | 4634| | // Validate against tag if one was specified 4635| | if (tag_specified_index.has_value() && 4636| | tag_specified_index.value() != static_cast(type_index)) { 4637| | ctx.error = error_code::no_matching_variant_type; 4638| | return; 4639| | } 4640| | 4641| | it = start; 4642| | if (value.index() != static_cast(type_index)) 4643| | emplace_runtime_variant(value, type_index); 4644| | std::visit( 4645| | [&](auto&& v) { 4646| | using V = std::decay_t; 4647| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4648| | if constexpr (variant_unit_alternative) { 4649| | // A unit alternative carries no data; its object holds only the discriminator. 4650| | // Consume that body through an empty reflected object so unknown-key policy and 4651| | // terminator handling match every other alternative. 4652| | detail::variant_unit_body unit_body{}; 4653| | from::template op(), 4654| | tag_literal>(unit_body, ctx, it, 4655| | end); 4656| | } 4657| | else if constexpr (is_object) { 4658| | from::template op(), tag_literal>(v, ctx, it, end); 4659| | } 4660| | else if constexpr (is_memory_object) { 4661| | if (!v) { 4662| | if constexpr (is_specialization_v) { 4663| | if constexpr (requires { v.emplace(); }) { 4664| | v.emplace(); 4665| | } 4666| | else { 4667| | v = typename V::value_type{}; 4668| | } 4669| | } 4670| | else if constexpr (is_specialization_v) 4671| | v = std::make_unique(); 4672| | else if constexpr (is_specialization_v) 4673| | v = std::make_shared(); 4674| | else if constexpr (constructible) { 4675| | v = meta_construct_v(); 4676| | } 4677| | else if constexpr (std::is_pointer_v && 4678| | can_allocate_raw_pointer>) { 4679| | if (!try_allocate_raw_pointer(v, ctx)) { 4680| | return; 4681| | } 4682| | } 4683| | else { 4684| | ctx.error = error_code::invalid_nullable_read; 4685| | return; 4686| | } 4687| | } 4688| | from>::template op(), tag_literal>(*v, ctx, 4689| | it, end); 4690| | } 4691| | else if constexpr (custom_read) { 4692| | // Custom handlers parse the remaining body themselves. 4693| | from::template op()>(v, ctx, it, end); 4694| | } 4695| | }, 4696| | value); 4697| | } 4698| | else if (final_matching > 1) { 4699| | constexpr auto N = std::variant_size_v; 4700| | 4701| | // Compile-time array of field counts for each variant type 4702| | constexpr auto field_counts = [](std::index_sequence) { 4703| | return std::array { 4704| | ([]() -> size_t { 4705| | using V = std::decay_t>; 4706| | if constexpr (glaze_object_t || reflectable) { 4707| | return reflect::size; 4708| | } 4709| | else if constexpr (is_memory_object) { 4710| | using X = memory_type; 4711| | if constexpr (glaze_object_t || reflectable) { 4712| | return reflect::size; 4713| | } 4714| | else { 4715| | return (std::numeric_limits::max)(); 4716| | } 4717| | } 4718| | else { 4719| | return (std::numeric_limits::max)(); 4720| | } 4721| | }.template operator()())... 4722| | }; 4723| | }(std::make_index_sequence{}); 4724| | 4725| | // Find the type with minimum field count among the possible types 4726| | size_t min_fields = (std::numeric_limits::max)(); 4727| | size_t chosen_index = N; // Invalid index initially 4728| | 4729| | for (size_t i = 0; i < N; ++i) { 4730| | if (possible_types[i] && field_counts[i] < min_fields) { 4731| | min_fields = field_counts[i]; 4732| | chosen_index = i; 4733| | } 4734| | } 4735| | 4736| | if (chosen_index < N) { 4737| | // Validate against tag if one was specified 4738| | if (tag_specified_index.has_value() && tag_specified_index.value() != chosen_index) { 4739| | ctx.error = error_code::no_matching_variant_type; 4740| | return; 4741| | } 4742| | 4743| | it = start; 4744| | if (value.index() != chosen_index) emplace_runtime_variant(value, chosen_index); 4745| | std::visit( 4746| | [&](auto&& v) { 4747| | using V = std::decay_t; 4748| | constexpr bool is_object = (glaze_object_t || reflectable) && not custom_read; 4749| | if constexpr (variant_unit_alternative) { 4750| | // A unit alternative carries no data; its object holds only the discriminator. 4751| | // Consume that body through an empty reflected object so unknown-key policy and 4752| | // terminator handling match every other alternative. 4753| | detail::variant_unit_body unit_body{}; 4754| | from::template op(), 4755| | tag_literal>(unit_body, ctx, it, 4756| | end); 4757| | } 4758| | else if constexpr (is_object) { 4759| | from::template op(), tag_literal>(v, ctx, it, end); 4760| | } 4761| | else if constexpr (is_memory_object) { 4762| | if (!v) { 4763| | if constexpr (is_specialization_v) { 4764| | if constexpr (requires { v.emplace(); }) { 4765| | v.emplace(); 4766| | } 4767| | else { 4768| | v = typename V::value_type{}; 4769| | } 4770| | } 4771| | else if constexpr (is_specialization_v) 4772| | v = std::make_unique(); 4773| | else if constexpr (is_specialization_v) 4774| | v = std::make_shared(); 4775| | else if constexpr (constructible) { 4776| | v = meta_construct_v(); 4777| | } 4778| | else if constexpr (std::is_pointer_v && 4779| | can_allocate_raw_pointer>) { 4780| | if (!try_allocate_raw_pointer(v, ctx)) { 4781| | return; 4782| | } 4783| | } 4784| | else { 4785| | ctx.error = error_code::invalid_nullable_read; 4786| | return; 4787| | } 4788| | } 4789| | from>::template op(), tag_literal>( 4790| | *v, ctx, it, end); 4791| | } 4792| | else if constexpr (custom_read) { 4793| | // Custom handlers parse the remaining body themselves. 4794| | from::template op()>(v, ctx, it, end); 4795| | } 4796| | }, 4797| | value); 4798| | } 4799| | else { 4800| | ctx.error = error_code::no_matching_variant_type; 4801| | } 4802| | } 4803| | } 4804| | else { 4805| | // For variants with 0 or 1 object types, use the original error handling 4806| | ctx.error = error_code::no_matching_variant_type; 4807| | } 4808| | } 4809| 0| break; 4810| 7.92k| } 4811| 1.98k| case '[': ------------------ | Branch (4811:13): [True: 1.98k, False: 11.0k] ------------------ 4812| | // As with '{' above: the array reader each alternative goes through counts the level. 4813| 1.98k| process_variant_alternatives::template op(value, ctx, it, end); 4814| 1.98k| break; 4815| 998| case '"': { ------------------ | Branch (4815:13): [True: 998, False: 12.0k] ------------------ 4816| 998| process_variant_alternatives::template op(value, ctx, it, end); 4817| 998| break; 4818| 7.92k| } 4819| 3| case 't': ------------------ | Branch (4819:13): [True: 3, False: 13.0k] ------------------ 4820| 6| case 'f': { ------------------ | Branch (4820:13): [True: 3, False: 13.0k] ------------------ 4821| 6| process_variant_alternatives::template op(value, ctx, it, end); 4822| 6| break; 4823| 3| } 4824| 31| case 'n': ------------------ | Branch (4824:13): [True: 31, False: 13.0k] ------------------ 4825| 31| if constexpr (variant_count_v == 0) { 4826| 31| ctx.error = error_code::no_matching_variant_type; 4827| | } 4828| | else { 4829| | constexpr auto first_idx = variant_first_index_v; 4830| | using V = std::variant_alternative_t; 4831| | if (!std::holds_alternative(value)) value = V{}; 4832| | match<"null", Opts>(ctx, it, end); 4833| | } 4834| 31| break; 4835| 1.88k| default: { ------------------ | Branch (4835:13): [True: 1.88k, False: 11.1k] ------------------ 4836| | // Not bool, string, object, or array so must be number or null 4837| 1.88k| process_variant_alternatives::template op(value, ctx, it, end); 4838| 1.88k| } 4839| 13.0k| } 4840| | } 4841| | else { 4842| | // For non-auto-deducible variants, try each type until one succeeds 4843| | constexpr auto N = std::variant_size_v; 4844| | bool parsed = false; 4845| | bool exhausted = false; // speculation budget spent; see charge_speculation 4846| | 4847| | for_each([&]() { 4848| | if (parsed || exhausted || variant_alternative_exhausted(ctx)) return; 4849| | 4850| | auto copy_it = it; 4851| | // A rejected alternative may have bailed out inside a container, which leaves its 4852| | // nesting level counted (see enter_depth), so the depth rewinds with the iterator. 4853| | const auto copy_depth = ctx.depth; 4854| | 4855| | // Try parsing as this type 4856| | if (value.index() != I) { 4857| | emplace_runtime_variant(value, I); 4858| | } 4859| | 4860| | std::visit([&](auto&& v) { parse::op(v, ctx, it, end); }, value); 4861| | if (bool(ctx.error) && !charge_speculation(ctx, size_t(it - copy_it))) { 4862| | exhausted = true; // only rejected attempts are charged; see charge_speculation 4863| | } 4864| | 4865| | if (!bool(ctx.error)) { 4866| | parsed = true; 4867| | } 4868| | else if constexpr (not Options.null_terminated) { 4869| | // In non-null-terminated mode, if we hit end_reached after advancing the iterator, 4870| | // it means we successfully parsed the value but couldn't skip trailing whitespace 4871| | if (ctx.error == error_code::end_reached && it > copy_it && not speculation_exhausted(ctx)) { 4872| | // We advanced the iterator, so we did parse something -- unless what advanced it 4873| | // was an abandoned attempt, which is what a spent speculation budget means. 4874| | parsed = true; 4875| | ctx.error = error_code::none; 4876| | } 4877| | else { 4878| | // Reset for next attempt (unless this is the last type) 4879| | it = copy_it; 4880| | rewind_depth(ctx, copy_depth); 4881| | if constexpr (I + 1 < N) { 4882| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4883| | ctx.error = error_code::none; // Clear error for next attempt 4884| | } 4885| | } 4886| | } 4887| | } 4888| | else { 4889| | // Reset for next attempt (unless this is the last type) 4890| | it = copy_it; 4891| | rewind_depth(ctx, copy_depth); 4892| | if constexpr (I + 1 < N) { 4893| | if (not exhausted && not variant_alternative_exhausted(ctx)) { 4894| | ctx.error = error_code::none; // Clear error for next attempt 4895| | } 4896| | } 4897| | } 4898| | }); 4899| | } 4900| 13.0k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS4_9allocatorIdEEEETkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 49| 13.0k| { 50| | if constexpr (const_value_v) { 51| | if constexpr (check_error_on_const_read(Opts)) { 52| | ctx.error = error_code::attempt_const_read; 53| | } 54| | else { 55| | // do not read anything into the const value 56| | skip_value::op(std::forward(ctx), std::forward(it), end); 57| | } 58| | } 59| 13.0k| else { 60| 13.0k| using V = std::remove_cvref_t; 61| 13.0k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 13.0k| end); 63| 13.0k| } 64| 13.0k| } _ZN3glz4fromILj10ENSt3__16vectorIdNS1_9allocatorIdEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS5_TkNS_10is_contextERNS_7contextERPKcSD_EEvOT0_OT1_OT2_T3_: 2349| 13.0k| { 2350| 13.0k| constexpr auto Opts = ws_handled_off(); 2351| 13.0k| if constexpr (!check_ws_handled(Options)) { 2352| 13.0k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2352:17): [True: 33, False: 13.0k] ------------------ 2353| 33| return; 2354| 33| } 2355| 13.0k| } 2356| | 2357| 13.0k| if (match_invalid_end<'[', Opts>(ctx, it, end)) { ------------------ | Branch (2357:14): [True: 11.0k, False: 2.01k] ------------------ 2358| 11.0k| return; 2359| 11.0k| } 2360| | // one nesting level (see enter_depth): counted in both modes so the limit binds, 2361| | // released at each syntactic close below 2362| 2.01k| if (enter_depth(ctx)) [[unlikely]] { ------------------ | Branch (2362:14): [True: 0, False: 2.01k] ------------------ 2363| 0| return; 2364| 0| } 2365| | 2366| 2.01k| const auto ws_start = it; 2367| 2.01k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2367:14): [True: 14, False: 2.00k] ------------------ 2368| 14| return; 2369| 14| } 2370| | 2371| 2.00k| if (*it == ']') { ------------------ | Branch (2371:14): [True: 5, False: 2.00k] ------------------ 2372| 5| --ctx.depth; 2373| 5| ++it; 2374| 5| if constexpr ((resizable || is_inplace_vector) && not check_append_arrays(Opts)) { 2375| 5| value.clear(); 2376| | 2377| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2378| | value.shrink_to_fit(); 2379| | } 2380| 5| } 2381| 5| return; 2382| 5| } 2383| | 2384| 2.00k| const size_t ws_size = size_t(it - ws_start); 2385| | 2386| 2.00k| static constexpr bool should_append = (resizable || is_inplace_vector) && check_append_arrays(Opts); ------------------ | Branch (2386:49): [True: 2.00k, Folded] | Branch (2386:65): [Folded, False: 0] | Branch (2386:90): [Folded, False: 0] ------------------ 2387| 2.00k| if constexpr (not should_append) { 2388| 2.00k| const auto n = value.size(); 2389| | 2390| 2.00k| auto value_it = value.begin(); 2391| | 2392| 2.00k| for (size_t i = 0; i < n; ++i) { ------------------ | Branch (2392:32): [True: 0, False: 2.00k] ------------------ 2393| 0| parse::op()>(*value_it++, ctx, it, end); 2394| 0| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2394:20): [True: 0, False: 0] ------------------ 2395| 0| return; 2396| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2396:20): [True: 0, False: 0] ------------------ 2397| 0| return; 2398| 0| } 2399| 0| if (*it == ',') { ------------------ | Branch (2399:20): [True: 0, False: 0] ------------------ 2400| 0| ++it; 2401| | 2402| 0| if constexpr (!Opts.minified && !Opts.comments) { 2403| 0| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2403:26): [True: 0, False: 0] | Branch (2403:37): [True: 0, False: 0] ------------------ 2404| 0| skip_matching_ws(ws_start, it, ws_size); 2405| 0| } 2406| 0| } 2407| | 2408| 0| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2408:23): [True: 0, False: 0] ------------------ 2409| 0| return; 2410| 0| } 2411| 0| } 2412| 0| else if (*it == ']') { ------------------ | Branch (2412:25): [True: 0, False: 0] ------------------ 2413| 0| --ctx.depth; 2414| 0| ++it; 2415| 0| if constexpr (erasable) { 2416| 0| value.erase(value_it, 2417| 0| value.end()); // use erase rather than resize for non-default constructible elements 2418| | 2419| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2420| | value.shrink_to_fit(); 2421| | } 2422| 0| } 2423| 0| return; 2424| 0| } 2425| 0| else [[unlikely]] { 2426| 0| ctx.error = error_code::expected_bracket; 2427| 0| return; 2428| 0| } 2429| 0| } 2430| 2.00k| } 2431| | 2432| | if constexpr (Opts.partial_read) { 2433| | // partial_read stops early on a success path, so give the level back like the 2434| | // syntactic-close paths do; otherwise it accumulates across reads sharing a context. 2435| | --ctx.depth; 2436| | return; 2437| | } 2438| 2.00k| else { 2439| | // growing 2440| 2.00k| if constexpr (emplace_backable || has_try_emplace_back) { 2441| 224k| while (it < end) { ------------------ | Branch (2441:23): [True: 224k, False: 33] ------------------ 2442| | // Streaming refill point: at start of each iteration, ensure buffer has data 2443| | if constexpr (has_streaming_state) { 2444| | if (ctx.stream.enabled()) { 2445| | const size_t consumed = static_cast(it - ctx.stream.data()); 2446| | const size_t remaining = ctx.stream.size() - consumed; 2447| | // Refill when less than half of buffer remains to ensure space for next element 2448| | if (remaining <= ctx.stream.size() / 2 || it >= end) { 2449| | const char* new_it; 2450| | const char* new_end; 2451| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2452| | it = new_it; 2453| | end = new_end; 2454| | if (it >= end && ctx.stream.at_eof()) { 2455| | break; // No more data, exit loop normally 2456| | } 2457| | } 2458| | } 2459| | } 2460| | 2461| | if constexpr (has_try_emplace_back) { 2462| | if (value.try_emplace_back()) 2463| | parse::op()>(value.back(), ctx, it, end); 2464| | else 2465| | ctx.error = error_code::exceeded_static_array_size; 2466| | } 2467| 224k| else { 2468| 224k| parse::op()>(value.emplace_back(), ctx, it, end); 2469| 224k| } 2470| | 2471| 224k| if (bool(ctx.error)) [[unlikely]] ------------------ | Branch (2471:23): [True: 938, False: 223k] ------------------ 2472| 938| return; 2473| | 2474| | // Streaming refill point: after parsing each element, refill if buffer is low 2475| | if constexpr (has_streaming_state) { 2476| | if (ctx.stream.enabled()) { 2477| | const size_t consumed = static_cast(it - ctx.stream.data()); 2478| | // Refill when less than 25% of buffer remains to ensure enough space for next element 2479| | if (ctx.stream.size() - consumed <= ctx.stream.size() / 4 || it >= end) { 2480| | const char* new_it; 2481| | const char* new_end; 2482| | ctx.stream.consume_and_refill(consumed, new_it, new_end); 2483| | it = new_it; 2484| | end = new_end; 2485| | if (it >= end && ctx.stream.at_eof()) { 2486| | ctx.error = error_code::unexpected_end; 2487| | return; 2488| | } 2489| | } 2490| | } 2491| | } 2492| | 2493| 223k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2493:23): [True: 28, False: 223k] ------------------ 2494| 28| return; 2495| 28| } 2496| 223k| if (*it == ',') [[likely]] { ------------------ | Branch (2496:23): [True: 222k, False: 936] ------------------ 2497| 222k| ++it; 2498| | 2499| 222k| if constexpr (!Opts.minified && !Opts.comments) { 2500| 222k| if (ws_size && ws_size < size_t(end - it)) { ------------------ | Branch (2500:29): [True: 180k, False: 41.9k] | Branch (2500:40): [True: 179k, False: 324] ------------------ 2501| 179k| skip_matching_ws(ws_start, it, ws_size); 2502| 179k| } 2503| 222k| } 2504| | 2505| 222k| if (skip_ws(ctx, it, end)) { ------------------ | Branch (2505:26): [True: 65, False: 222k] ------------------ 2506| 65| return; 2507| 65| } 2508| 222k| } 2509| 936| else if (*it == ']') { ------------------ | Branch (2509:28): [True: 403, False: 533] ------------------ 2510| 403| --ctx.depth; 2511| 403| ++it; 2512| | if constexpr (check_shrink_to_fit(Opts) && has_shrink_to_fit) { 2513| | value.shrink_to_fit(); 2514| | } 2515| 403| return; 2516| 403| } 2517| 533| else [[unlikely]] { 2518| 533| ctx.error = error_code::expected_bracket; 2519| 533| return; 2520| 533| } 2521| 223k| } 2522| | 2523| | // A valid array always returns from inside the loop upon reaching ']'. 2524| | // For a null-terminated buffer the loop can only exit here by falling 2525| | // through when `it` reaches the terminator without a closing bracket, 2526| | // which means the input was truncated (e.g. "[", "[1," or "[1,2,"). 2527| | // Non-null-terminated buffers surface this through skip_ws/depth 2528| | // tracking (or the streaming refill break), so this guard is limited 2529| | // to the null-terminated case. 2530| | if constexpr (Opts.null_terminated) { 2531| | ctx.error = error_code::unexpected_end; 2532| | } 2533| | } 2534| | else { 2535| | ctx.error = error_code::exceeded_static_array_size; 2536| | } 2537| 2.00k| } 2538| 2.00k| } _ZN3glz5parseILj10EE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEERdTkNS_10is_contextERNS_7contextERPKcS8_EEvOT0_OT1_OT2_T3_: 49| 224k| { 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| 224k| else { 60| 224k| using V = std::remove_cvref_t; 61| 224k| from::template op(std::forward(value), std::forward(ctx), std::forward(it), 62| 224k| end); 63| 224k| } 64| 224k| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 737| 138| { 738| | if constexpr (not check_write_unchecked(Opts)) { 739| | static_assert(required_padding()); 740| | if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { 741| | return; 742| | } 743| | } 744| | 745| 138| static constexpr auto O = write_unchecked_on(); 746| | 747| | if constexpr (check_quoted_num(Opts)) { 748| | std::memcpy(&b[ix], "\"", 1); 749| | ++ix; 750| | write_chars::op(value, ctx, b, ix); 751| | std::memcpy(&b[ix], "\"", 1); 752| | ++ix; 753| | } 754| 138| else { 755| 138| write_chars::op(value, ctx, b, ix); 756| 138| } 757| 138| } _ZN3glz2toILj10EDnE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDnTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1649| 19.7k| { 1650| 19.7k| if constexpr (not check_write_unchecked(Opts)) { 1651| 19.7k| if (!ensure_space(ctx, b, ix + 4)) [[unlikely]] { ------------------ | Branch (1651:17): [True: 0, False: 19.7k] ------------------ 1652| 0| return; 1653| 0| } 1654| 19.7k| } 1655| | if constexpr (std::endian::native == std::endian::big) { 1656| | static constexpr char null_v[] = "null"; 1657| | std::memcpy(&b[ix], null_v, 4); 1658| | } 1659| 19.7k| else { 1660| 19.7k| static constexpr uint32_t null_v = 1819047278; 1661| 19.7k| std::memcpy(&b[ix], &null_v, 4); 1662| 19.7k| } 1663| 19.7k| ix += 4; 1664| 19.7k| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 737| 400| { 738| 400| if constexpr (not check_write_unchecked(Opts)) { 739| 400| static_assert(required_padding()); 740| 400| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (740:17): [True: 0, False: 400] ------------------ 741| 0| return; 742| 0| } 743| 400| } 744| | 745| 400| static constexpr auto O = write_unchecked_on(); 746| | 747| | if constexpr (check_quoted_num(Opts)) { 748| | std::memcpy(&b[ix], "\"", 1); 749| | ++ix; 750| | write_chars::op(value, ctx, b, ix); 751| | std::memcpy(&b[ix], "\"", 1); 752| | ++ix; 753| | } 754| 400| else { 755| 400| write_chars::op(value, ctx, b, ix); 756| 400| } 757| 400| } _ZN3glz16required_paddingIiEEmv: 461| 753| { 462| 753| constexpr auto value = []() -> size_t { 463| 753| if constexpr (boolean_like) { 464| 753| return 8; 465| 753| } 466| 753| else if constexpr (num_t) { 467| 753| if constexpr (std::floating_point) { 468| 753| if constexpr (sizeof(T) > 8) { 469| 753| return 64; 470| 753| } 471| 753| else if constexpr (sizeof(T) > 4) { 472| | // zmij scratch + 4 for optional quotes and trailing comma. 473| 753| return zmij::double_buffer_size + 4; 474| 753| } 475| 753| else { 476| 753| return zmij::float_buffer_size + 4; 477| 753| } 478| 753| } 479| 753| else if constexpr (sizeof(T) > 4) { 480| 753| return 24; 481| 753| } 482| 753| else if constexpr (sizeof(T) > 2) { 483| 753| return 16; 484| 753| } 485| 753| else { 486| 753| return 8; 487| 753| } 488| 753| } 489| 753| else if constexpr (nullable_like) { 490| 753| if constexpr (has_value_type) { 491| 753| return required_padding(); 492| 753| } 493| 753| else if constexpr (has_element_type) { 494| 753| return required_padding(); 495| 753| } 496| 753| else { 497| 753| return 0; 498| 753| } 499| 753| } 500| 753| else if constexpr (always_null_t) { 501| 753| return 8; 502| 753| } 503| 753| else { 504| 753| return 0; 505| 753| } 506| 753| }(); 507| | 508| | if constexpr (value >= (write_padding_bytes - 16)) { 509| | // we always require 16 bytes available from write_padding_bytes 510| | // for opening and closing characters 511| | return 0; 512| | } 513| 753| return value; 514| 753| } _ZN3glz2toILj10EiE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 737| 353| { 738| 353| if constexpr (not check_write_unchecked(Opts)) { 739| 353| static_assert(required_padding()); 740| 353| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (740:17): [True: 0, False: 353] ------------------ 741| 0| return; 742| 0| } 743| 353| } 744| | 745| 353| static constexpr auto O = write_unchecked_on(); 746| | 747| | if constexpr (check_quoted_num(Opts)) { 748| | std::memcpy(&b[ix], "\"", 1); 749| | ++ix; 750| | write_chars::op(value, ctx, b, ix); 751| | std::memcpy(&b[ix], "\"", 1); 752| | ++ix; 753| | } 754| 353| else { 755| 353| write_chars::op(value, ctx, b, ix); 756| 353| } 757| 353| } _ZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2273| 112| { 2274| 112| using ValueType = std::decay_t; 2275| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2276| | constexpr auto& writer = meta_unknown_write_v; 2277| | 2278| | using WriterType = meta_unknown_write_t; 2279| | if constexpr (std::is_member_object_pointer_v) { 2280| | decltype(auto) unknown_writer = value.*writer; 2281| | if (unknown_writer.size() > 0) { 2282| | // TODO: This intermediate is added to get GCC 14 to build 2283| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2284| | serialize::op()>(std::move(merged), ctx, b, ix); 2285| | } 2286| | else { 2287| | serialize::op()>(value, ctx, b, ix); 2288| | } 2289| | } 2290| | else if constexpr (std::is_member_function_pointer_v) { 2291| | decltype(auto) unknown_writer = (value.*writer)(); 2292| | if (unknown_writer.size() > 0) { 2293| | // TODO: This intermediate is added to get GCC 14 to build 2294| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2295| | serialize::op()>(std::move(merged), ctx, b, ix); 2296| | } 2297| | else { 2298| | serialize::op()>(value, ctx, b, ix); 2299| | } 2300| | } 2301| | else { 2302| | static_assert(false_v, "unknown_write type not handled"); 2303| | } 2304| | } 2305| 112| else { 2306| | // handles glaze_object_t without extra unknown fields 2307| 112| static constexpr auto Opts = 2308| 112| disable_write_unknown_off()>()>(); 2309| | 2310| 112| if constexpr (not check_opening_handled(Options)) { 2311| | if constexpr (Options.prettify) { 2312| | ctx.depth += check_indentation_width(Options); 2313| | if constexpr (not check_write_unchecked(Options)) { 2314| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2315| | return; 2316| | } 2317| | } 2318| | std::memcpy(&b[ix], "{\n", 2); 2319| | ix += 2; 2320| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2321| | ix += ctx.depth; 2322| | } 2323| 112| else { 2324| 112| if constexpr (not check_write_unchecked(Options)) { 2325| 112| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2325:26): [True: 0, False: 112] ------------------ 2326| 0| return; 2327| 0| } 2328| 112| } 2329| 112| dump('{', b, ix); 2330| 112| } 2331| 112| } 2332| | 2333| 0| static constexpr auto N = reflect::size; 2334| | 2335| 112| decltype(auto) t = [&]() -> decltype(auto) { 2336| 112| if constexpr (reflectable) { 2337| 112| return to_tie(value); 2338| 112| } 2339| 112| else { 2340| 112| return nullptr; 2341| 112| } 2342| 112| }(); 2343| | 2344| 112| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2345| | if constexpr (maybe_skipped) { 2346| | bool first = true; 2347| | for_each([&]() { 2348| | using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| | else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| | if (is_glaze_value_field_null(value, t)) return; 2406| | } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| | else { 2426| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2427| | return; 2428| | } 2429| | } 2430| | 2431| | if (first) { 2432| | first = false; 2433| | } 2434| | else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| | else { 2443| | std::memcpy(&b[ix], ",", 1); 2444| | ++ix; 2445| | } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| | } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| | static constexpr auto quoted_key = quoted_key_v; 2454| | static constexpr auto n = quoted_key.size(); 2455| | std::memcpy(&b[ix], quoted_key.data(), n); 2456| | ix += n; 2457| | 2458| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2459| | if constexpr (reflectable) { 2460| | to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| | } 2467| | }); 2468| | } 2469| 112| else { 2470| 112| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2470:57): [Folded, False: 112] ------------------ 2471| 112| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2472| 112| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2472:23): [True: 0, False: 112] ------------------ 2473| 0| return; 2474| 0| } 2475| 112| } 2476| | 2477| 112| for_each([&]() { 2478| 112| if constexpr (write_can_error()) { 2479| 112| if (bool(ctx.error)) [[unlikely]] { 2480| 112| return; 2481| 112| } 2482| 112| } 2483| 112| if constexpr (not fixed_max_size) { 2484| 112| if constexpr (Opts.prettify) { 2485| 112| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| 112| return; 2487| 112| } 2488| 112| } 2489| 112| else { 2490| 112| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| 112| return; 2492| 112| } 2493| 112| } 2494| 112| } 2495| | 2496| 112| if constexpr (I != 0 && Opts.prettify) { 2497| 112| std::memcpy(&b[ix], ",\n", 2); 2498| 112| ix += 2; 2499| 112| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| 112| ix += ctx.depth; 2501| 112| } 2502| | 2503| 112| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 112| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| 112| if constexpr (always_null_t) { 2508| 112| if constexpr (I == 0 || Opts.prettify) { 2509| 112| static constexpr auto quoted_key = join_v, chars<"null">>; 2510| 112| static constexpr auto n = quoted_key.size(); 2511| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2512| 112| ix += n; 2513| 112| } 2514| 112| else { 2515| 112| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| 112| static constexpr auto n = quoted_key.size(); 2517| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2518| 112| ix += n; 2519| 112| } 2520| 112| } 2521| 112| else { 2522| 112| if constexpr (I == 0 || Opts.prettify) { 2523| 112| static constexpr auto quoted_key = quoted_key_v; 2524| 112| static constexpr auto n = quoted_key.size(); 2525| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 112| ix += n; 2527| 112| } 2528| 112| else { 2529| 112| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 112| static constexpr auto n = quoted_key.size(); 2531| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 112| ix += n; 2533| 112| } 2534| | 2535| 112| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2536| 112| if constexpr (reflectable) { 2537| 112| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| 112| } 2539| 112| else { 2540| 112| to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| 112| ix); 2542| 112| } 2543| 112| } 2544| 112| }); 2545| 112| } 2546| | 2547| | // Options is required here, because it must be the top level 2548| 112| if constexpr (not check_closing_handled(Options)) { 2549| | if constexpr (Options.prettify) { 2550| | ctx.depth -= check_indentation_width(Options); 2551| | if constexpr (not check_write_unchecked(Options)) { 2552| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2553| | return; 2554| | } 2555| | } 2556| | std::memcpy(&b[ix], "\n", 1); 2557| | ++ix; 2558| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2559| | ix += ctx.depth; 2560| | std::memcpy(&b[ix], "}", 1); 2561| | ++ix; 2562| | } 2563| 112| else { 2564| 112| dump || check_write_unchecked(Options))>('}', b, ix); 2565| 112| } 2566| 112| } 2567| 112| } 2568| 112| } _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2335| 112| decltype(auto) t = [&]() -> decltype(auto) { 2336| 112| if constexpr (reflectable) { 2337| 112| return to_tie(value); 2338| | } 2339| | else { 2340| | return nullptr; 2341| | } 2342| 112| }(); _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2477| 112| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| | if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| | else { 2490| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| | return; 2492| | } 2493| | } 2494| | } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 112| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 112| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 112| else { 2522| 112| if constexpr (I == 0 || Opts.prettify) { 2523| 112| static constexpr auto quoted_key = quoted_key_v; 2524| 112| static constexpr auto n = quoted_key.size(); 2525| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 112| ix += n; 2527| | } 2528| | else { 2529| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| | static constexpr auto n = quoted_key.size(); 2531| | std::memcpy(&b[ix], quoted_key.data(), n); 2532| | ix += n; 2533| | } 2534| | 2535| 112| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [True: 0, Folded] ------------------ 2536| 112| if constexpr (reflectable) { 2537| 112| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 112| } 2544| 112| }); _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj128EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 737| 544| { 738| | if constexpr (not check_write_unchecked(Opts)) { 739| | static_assert(required_padding()); 740| | if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { 741| | return; 742| | } 743| | } 744| | 745| 544| static constexpr auto O = write_unchecked_on(); 746| | 747| | if constexpr (check_quoted_num(Opts)) { 748| | std::memcpy(&b[ix], "\"", 1); 749| | ++ix; 750| | write_chars::op(value, ctx, b, ix); 751| | std::memcpy(&b[ix], "\"", 1); 752| | ++ix; 753| | } 754| 544| else { 755| 544| write_chars::op(value, ctx, b, ix); 756| 544| } 757| 544| } _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES2_RNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2477| 112| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| | if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| | else { 2490| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| | return; 2492| | } 2493| | } 2494| | } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 112| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 112| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 112| else { 2522| | if constexpr (I == 0 || Opts.prettify) { 2523| | static constexpr auto quoted_key = quoted_key_v; 2524| | static constexpr auto n = quoted_key.size(); 2525| | std::memcpy(&b[ix], quoted_key.data(), n); 2526| | ix += n; 2527| | } 2528| 112| else { 2529| 112| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 112| static constexpr auto n = quoted_key.size(); 2531| 112| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 112| ix += n; 2533| 112| } 2534| | 2535| 112| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [True: 0, Folded] ------------------ 2536| 112| if constexpr (reflectable) { 2537| 112| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 112| } 2544| 112| }); _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 768| 247| { 769| | if constexpr (check_string_as_number(Opts)) { 770| | const sv str = [&]() -> const sv { 771| | if constexpr (array_char_t) { 772| | const auto* start = value.data(); 773| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 774| | return sv{start, end ? size_t(end - start) : value.size()}; 775| | } 776| | else if constexpr (u8str_t) { 777| | return sv{reinterpret_cast(value.data()), value.size()}; 778| | } 779| | else { 780| | return str_view(value); 781| | } 782| | }(); 783| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 784| | return; 785| | } 786| | dump_maybe_empty(str, b, ix); 787| | } 788| | else if constexpr (char_t) { 789| | if constexpr (check_unquoted(Opts)) { 790| | dump(value, b, ix); 791| | } 792| | else { 793| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 794| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 795| | return; 796| | } 797| | 798| | std::memcpy(&b[ix], "\"", 1); 799| | ++ix; 800| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 801| | std::memcpy(&b[ix], &escaped, 2); 802| | ix += 2; 803| | } 804| | else if (value == '\0') { 805| | // null character treated as empty string 806| | } 807| | else if constexpr (check_escape_control_characters(Opts)) { 808| | if (uint8_t(value) < 0x20) { 809| | // Write as \uXXXX format 810| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 811| | constexpr char hex_digits[] = "0123456789ABCDEF"; 812| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 813| | unicode_escape[5] = hex_digits[value & 0xF]; 814| | std::memcpy(&b[ix], unicode_escape, 6); 815| | ix += 6; 816| | } 817| | else { 818| | std::memcpy(&b[ix], &value, 1); 819| | ++ix; 820| | } 821| | } 822| | else { 823| | std::memcpy(&b[ix], &value, 1); 824| | ++ix; 825| | } 826| | std::memcpy(&b[ix], "\"", 1); 827| | ++ix; 828| | } 829| | } 830| 247| else { 831| | if constexpr (check_raw_string(Opts)) { 832| | const sv str = [&]() -> const sv { 833| | if constexpr (u8str_t) { 834| | return sv{reinterpret_cast(value.data()), value.size()}; 835| | } 836| | else { 837| | return str_view(value); 838| | } 839| | }(); 840| | 841| | // We need space for quotes and the string length: 2 + n. 842| | // Use +8 for extra buffer 843| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 844| | return; 845| | } 846| | // now we don't have to check writing 847| | 848| | if constexpr (not check_unquoted(Opts)) { 849| | std::memcpy(&b[ix], "\"", 1); 850| | ++ix; 851| | } 852| | if (str.size()) [[likely]] { 853| | const auto n = str.size(); 854| | std::memcpy(&b[ix], str.data(), n); 855| | ix += n; 856| | } 857| | if constexpr (not check_unquoted(Opts)) { 858| | std::memcpy(&b[ix], "\"", 1); 859| | ++ix; 860| | } 861| | } 862| 247| else { 863| 247| const sv str = [&]() -> const sv { 864| 247| if constexpr (array_char_t) { 865| 247| return sv{value.data(), value.size()}; 866| 247| } 867| 247| else if constexpr (u8str_t) { 868| 247| return sv{reinterpret_cast(value.data()), value.size()}; 869| 247| } 870| 247| else { 871| 247| return str_view(value); 872| 247| } 873| 247| }(); 874| 247| const auto n = str.size(); 875| | 876| | // In the case n == 0 we need two characters for quotes. 877| | // For each individual character we need room for two characters to handle escapes. 878| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 879| | if constexpr (check_escape_control_characters(Opts)) { 880| | // We need 2 + 6 * n characters in the worst case (all control chars) 881| | if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 882| | return; 883| | } 884| | } 885| 247| else { 886| | // Using the original sizing 887| 247| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (887:23): [True: 0, False: 247] ------------------ 888| 0| return; 889| 0| } 890| 247| } 891| | // now we don't have to check writing 892| | 893| | if constexpr (check_unquoted(Opts)) { 894| | if (n) { 895| | std::memcpy(&b[ix], str.data(), n); 896| | ix += n; 897| | } 898| | } 899| 247| else { 900| 247| std::memcpy(&b[ix], "\"", 1); 901| 247| ++ix; 902| | 903| 247| const auto* c = str.data(); 904| 247| const auto* const e = c + n; 905| 247| const auto start = &b[ix]; 906| 247| auto data = start; 907| | 908| | // By default we don't escape control characters for performance. Invalid JSON characters 909| | // result in null characters in the output, making the JSON invalid — these would then be 910| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 911| | // control characters (0x00–0x1F) as \uXXXX sequences. 912| | 913| | // Escape handler: writes the escaped form of *c into data, advances both pointers 914| 247| auto write_escape = [&]() { 915| 247| if constexpr (check_escape_control_characters(Opts)) { 916| 247| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 917| 247| std::memcpy(data, &escaped, 2); 918| 247| data += 2; 919| 247| } 920| 247| else { 921| 247| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 922| 247| constexpr char hex_digits[] = "0123456789ABCDEF"; 923| 247| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 924| 247| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 925| 247| std::memcpy(data, unicode_escape, 6); 926| 247| data += 6; 927| 247| } 928| 247| } 929| 247| else { 930| 247| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 931| 247| data += 2; 932| 247| } 933| 247| ++c; 934| 247| }; 935| | 936| | // Adding a helper here means adding a branch to string_escape_simd() in 937| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 938| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 939| |#if defined(GLZ_USE_AVX2) 940| | detail::avx2_string_escape(c, e, data, n, write_escape); 941| |#endif 942| 247|#if defined(GLZ_USE_SSE2) 943| 247| detail::sse2_string_escape(c, e, data, n, write_escape); 944| |#elif defined(GLZ_USE_NEON) 945| | detail::neon_string_escape(c, e, data, n, write_escape); 946| |#endif 947| | 948| | // SWAR: 8 bytes at a time 949| 247| if (n > 7) { ------------------ | Branch (949:23): [True: 163, False: 84] ------------------ 950| 496| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (950:54): [True: 333, False: 163] ------------------ 951| 333| std::memcpy(data, c, 8); 952| 333| uint64_t swar; 953| 333| std::memcpy(&swar, c, 8); 954| | if constexpr (std::endian::native == std::endian::big) { 955| | swar = std::byteswap(swar); 956| | } 957| | 958| 333| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 959| 333| const uint64_t lo7 = swar & lo7_mask; 960| 333| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 961| 333| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 962| 333| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 963| 333| uint64_t next = ~((quote & backslash & less_32) | swar); 964| | 965| 333| next &= repeat_byte8(0b10000000); 966| 333| if (next == 0) { ------------------ | Branch (966:29): [True: 62, False: 271] ------------------ 967| 62| data += 8; 968| 62| c += 8; 969| 62| continue; 970| 62| } 971| | 972| 271| const auto length = (countr_zero(next) >> 3); 973| 271| c += length; 974| 271| data += length; 975| 271| write_escape(); 976| 271| } 977| 163| } 978| | 979| | // Scalar tail 980| 1.01k| for (; c < e; ++c) { ------------------ | Branch (980:26): [True: 764, False: 247] ------------------ 981| 764| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (981:79): [True: 315, False: 449] ------------------ 982| 315| std::memcpy(data, &escaped, 2); 983| 315| data += 2; 984| 315| } 985| | else if constexpr (check_escape_control_characters(Opts)) { 986| | if (uint8_t(*c) < 0x20) { 987| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 988| | constexpr char hex_digits[] = "0123456789ABCDEF"; 989| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 990| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 991| | std::memcpy(data, unicode_escape, 6); 992| | data += 6; 993| | } 994| | else { 995| | std::memcpy(data, c, 1); 996| | ++data; 997| | } 998| | } 999| 449| else { 1000| 449| std::memcpy(data, c, 1); 1001| 449| ++data; 1002| 449| } 1003| 764| } 1004| | 1005| 247| ix += size_t(data - start); 1006| | 1007| 247| std::memcpy(&b[ix], "\"", 1); 1008| 247| ++ix; 1009| 247| } 1010| 247| } 1011| 247| } 1012| 247| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 863| 247| const sv str = [&]() -> const sv { 864| | if constexpr (array_char_t) { 865| | return sv{value.data(), value.size()}; 866| | } 867| | else if constexpr (u8str_t) { 868| | return sv{reinterpret_cast(value.data()), value.size()}; 869| | } 870| 247| else { 871| 247| return str_view(value); 872| 247| } 873| 247| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_S7_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 914| 43.5k| auto write_escape = [&]() { 915| | if constexpr (check_escape_control_characters(Opts)) { 916| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 917| | std::memcpy(data, &escaped, 2); 918| | data += 2; 919| | } 920| | else { 921| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 922| | constexpr char hex_digits[] = "0123456789ABCDEF"; 923| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 924| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 925| | std::memcpy(data, unicode_escape, 6); 926| | data += 6; 927| | } 928| | } 929| 43.5k| else { 930| 43.5k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 931| 43.5k| data += 2; 932| 43.5k| } 933| 43.5k| ++c; 934| 43.5k| }; _ZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2273| 47| { 2274| 47| using ValueType = std::decay_t; 2275| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2276| | constexpr auto& writer = meta_unknown_write_v; 2277| | 2278| | using WriterType = meta_unknown_write_t; 2279| | if constexpr (std::is_member_object_pointer_v) { 2280| | decltype(auto) unknown_writer = value.*writer; 2281| | if (unknown_writer.size() > 0) { 2282| | // TODO: This intermediate is added to get GCC 14 to build 2283| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2284| | serialize::op()>(std::move(merged), ctx, b, ix); 2285| | } 2286| | else { 2287| | serialize::op()>(value, ctx, b, ix); 2288| | } 2289| | } 2290| | else if constexpr (std::is_member_function_pointer_v) { 2291| | decltype(auto) unknown_writer = (value.*writer)(); 2292| | if (unknown_writer.size() > 0) { 2293| | // TODO: This intermediate is added to get GCC 14 to build 2294| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2295| | serialize::op()>(std::move(merged), ctx, b, ix); 2296| | } 2297| | else { 2298| | serialize::op()>(value, ctx, b, ix); 2299| | } 2300| | } 2301| | else { 2302| | static_assert(false_v, "unknown_write type not handled"); 2303| | } 2304| | } 2305| 47| else { 2306| | // handles glaze_object_t without extra unknown fields 2307| 47| static constexpr auto Opts = 2308| 47| disable_write_unknown_off()>()>(); 2309| | 2310| 47| if constexpr (not check_opening_handled(Options)) { 2311| | if constexpr (Options.prettify) { 2312| | ctx.depth += check_indentation_width(Options); 2313| | if constexpr (not check_write_unchecked(Options)) { 2314| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2315| | return; 2316| | } 2317| | } 2318| | std::memcpy(&b[ix], "{\n", 2); 2319| | ix += 2; 2320| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2321| | ix += ctx.depth; 2322| | } 2323| 47| else { 2324| 47| if constexpr (not check_write_unchecked(Options)) { 2325| 47| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2325:26): [True: 0, False: 47] ------------------ 2326| 0| return; 2327| 0| } 2328| 47| } 2329| 47| dump('{', b, ix); 2330| 47| } 2331| 47| } 2332| | 2333| 0| static constexpr auto N = reflect::size; 2334| | 2335| 47| decltype(auto) t = [&]() -> decltype(auto) { 2336| 47| if constexpr (reflectable) { 2337| 47| return to_tie(value); 2338| 47| } 2339| 47| else { 2340| 47| return nullptr; 2341| 47| } 2342| 47| }(); 2343| | 2344| 47| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2345| 47| if constexpr (maybe_skipped) { 2346| 47| bool first = true; 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| 47| if constexpr (meta_has_skip) { 2351| 47| static constexpr meta_context mctx{.op = operation::serialize}; 2352| 47| if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| 47| } 2354| 47| if constexpr (meta_has_skip_if) { 2355| 47| static constexpr auto key = glz::get(reflect::keys); 2356| 47| static constexpr meta_context mctx{.op = operation::serialize}; 2357| 47| decltype(auto) field_value = [&]() -> decltype(auto) { 2358| 47| if constexpr (reflectable) { 2359| 47| return get(t); 2360| 47| } 2361| 47| else { 2362| 47| return get_member(value, glz::get(reflect::values)); 2363| 47| } 2364| 47| }(); 2365| 47| if (meta::skip_if(field_value, key, mctx)) return; 2366| 47| } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| 47| if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| 47| return; 2371| 47| } 2372| 47| else { 2373| 47| if constexpr (null_t && Opts.skip_null_members) { 2374| 47| if constexpr (always_null_t) 2375| 47| return; 2376| 47| else { 2377| 47| const auto is_null = [&]() { 2378| 47| decltype(auto) element = [&]() -> decltype(auto) { 2379| 47| if constexpr (reflectable) { 2380| 47| return get(t); 2381| 47| } 2382| 47| else { 2383| 47| return get(reflect::values); 2384| 47| } 2385| 47| }; 2386| | 2387| 47| if constexpr (nullable_wrapper) { 2388| 47| return !bool(element()(value).val); 2389| 47| } 2390| 47| else if constexpr (nullable_value_t) { 2391| 47| return !get_member(value, element()).has_value(); 2392| 47| } 2393| 47| else { 2394| 47| return !bool(get_member(value, element())); 2395| 47| } 2396| 47| }(); 2397| 47| if (is_null) return; 2398| 47| } 2399| 47| } 2400| 47| else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| 47| custom_getter_returns_nullable()) { 2402| 47| if (is_custom_field_null(value, t, ctx)) return; 2403| 47| } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| 47| if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| 47| decltype(auto) member = [&]() -> decltype(auto) { 2410| 47| if constexpr (reflectable) { 2411| 47| return get_member(value, get(t)); 2412| 47| } 2413| 47| else { 2414| 47| return get_member(value, get(reflect::values)); 2415| 47| } 2416| 47| }(); 2417| 47| if (is_default_value(member)) return; 2418| 47| } 2419| | 2420| 47| if constexpr (Opts.prettify) { 2421| 47| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| 47| return; 2423| 47| } 2424| 47| } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2427| 47| return; 2428| 47| } 2429| 47| } 2430| | 2431| 47| if (first) { 2432| 47| first = false; 2433| 47| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| 47| if constexpr (Opts.prettify) { 2437| 47| std::memcpy(&b[ix], ",\n", 2); 2438| 47| ix += 2; 2439| 47| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| 47| ix += ctx.depth; 2441| 47| } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| 47| if constexpr (is_output_streaming) { 2447| 47| flush_buffer(b, ix); 2448| 47| } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| 47| } 2462| 47| else { 2463| 47| to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| 47| ix); 2465| 47| } 2466| 47| } 2467| 47| }); 2468| | } 2469| | else { 2470| | static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; 2471| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2472| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2473| | return; 2474| | } 2475| | } 2476| | 2477| | for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| | if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| | else { 2490| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| | return; 2492| | } 2493| | } 2494| | } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| | using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| | else { 2522| | if constexpr (I == 0 || Opts.prettify) { 2523| | static constexpr auto quoted_key = quoted_key_v; 2524| | static constexpr auto n = quoted_key.size(); 2525| | std::memcpy(&b[ix], quoted_key.data(), n); 2526| | ix += n; 2527| | } 2528| | else { 2529| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| | static constexpr auto n = quoted_key.size(); 2531| | std::memcpy(&b[ix], quoted_key.data(), n); 2532| | ix += n; 2533| | } 2534| | 2535| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2536| | if constexpr (reflectable) { 2537| | to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| | } 2544| | }); 2545| | } 2546| | 2547| | // Options is required here, because it must be the top level 2548| 47| if constexpr (not check_closing_handled(Options)) { 2549| | if constexpr (Options.prettify) { 2550| | ctx.depth -= check_indentation_width(Options); 2551| | if constexpr (not check_write_unchecked(Options)) { 2552| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2553| | return; 2554| | } 2555| | } 2556| | std::memcpy(&b[ix], "\n", 1); 2557| | ++ix; 2558| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2559| | ix += ctx.depth; 2560| | std::memcpy(&b[ix], "}", 1); 2561| | ++ix; 2562| | } 2563| 47| else { 2564| 47| dump || check_write_unchecked(Options))>('}', b, ix); 2565| 47| } 2566| 47| } 2567| 47| } 2568| 47| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2335| 47| decltype(auto) t = [&]() -> decltype(auto) { 2336| 47| if constexpr (reflectable) { 2337| 47| return to_tie(value); 2338| | } 2339| | else { 2340| | return nullptr; 2341| | } 2342| 47| }(); _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 47, False: 0] ------------------ 2432| 47| first = false; 2433| 47| } 2434| 0| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 0| else { 2443| 0| std::memcpy(&b[ix], ",", 1); 2444| 0| ++ix; 2445| 0| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 0| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [True: 0, Folded] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 768| 596| { 769| | if constexpr (check_string_as_number(Opts)) { 770| | const sv str = [&]() -> const sv { 771| | if constexpr (array_char_t) { 772| | const auto* start = value.data(); 773| | const auto* end = static_cast(std::memchr(start, '\0', value.size())); 774| | return sv{start, end ? size_t(end - start) : value.size()}; 775| | } 776| | else if constexpr (u8str_t) { 777| | return sv{reinterpret_cast(value.data()), value.size()}; 778| | } 779| | else { 780| | return str_view(value); 781| | } 782| | }(); 783| | if (!ensure_space(ctx, b, ix + str.size() + write_padding_bytes)) [[unlikely]] { 784| | return; 785| | } 786| | dump_maybe_empty(str, b, ix); 787| | } 788| | else if constexpr (char_t) { 789| | if constexpr (check_unquoted(Opts)) { 790| | dump(value, b, ix); 791| | } 792| | else { 793| | // 8 bytes is enough for quotes and escaped character (worst case: \uXXXX = 6 + 2 quotes) 794| | if (!ensure_space(ctx, b, ix + 8)) [[unlikely]] { 795| | return; 796| | } 797| | 798| | std::memcpy(&b[ix], "\"", 1); 799| | ++ix; 800| | if (const auto escaped = char_escape_table[uint8_t(value)]; escaped) { 801| | std::memcpy(&b[ix], &escaped, 2); 802| | ix += 2; 803| | } 804| | else if (value == '\0') { 805| | // null character treated as empty string 806| | } 807| | else if constexpr (check_escape_control_characters(Opts)) { 808| | if (uint8_t(value) < 0x20) { 809| | // Write as \uXXXX format 810| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 811| | constexpr char hex_digits[] = "0123456789ABCDEF"; 812| | unicode_escape[4] = hex_digits[(value >> 4) & 0xF]; 813| | unicode_escape[5] = hex_digits[value & 0xF]; 814| | std::memcpy(&b[ix], unicode_escape, 6); 815| | ix += 6; 816| | } 817| | else { 818| | std::memcpy(&b[ix], &value, 1); 819| | ++ix; 820| | } 821| | } 822| | else { 823| | std::memcpy(&b[ix], &value, 1); 824| | ++ix; 825| | } 826| | std::memcpy(&b[ix], "\"", 1); 827| | ++ix; 828| | } 829| | } 830| 596| else { 831| | if constexpr (check_raw_string(Opts)) { 832| | const sv str = [&]() -> const sv { 833| | if constexpr (u8str_t) { 834| | return sv{reinterpret_cast(value.data()), value.size()}; 835| | } 836| | else { 837| | return str_view(value); 838| | } 839| | }(); 840| | 841| | // We need space for quotes and the string length: 2 + n. 842| | // Use +8 for extra buffer 843| | if (!ensure_space(ctx, b, ix + 8 + str.size())) [[unlikely]] { 844| | return; 845| | } 846| | // now we don't have to check writing 847| | 848| | if constexpr (not check_unquoted(Opts)) { 849| | std::memcpy(&b[ix], "\"", 1); 850| | ++ix; 851| | } 852| | if (str.size()) [[likely]] { 853| | const auto n = str.size(); 854| | std::memcpy(&b[ix], str.data(), n); 855| | ix += n; 856| | } 857| | if constexpr (not check_unquoted(Opts)) { 858| | std::memcpy(&b[ix], "\"", 1); 859| | ++ix; 860| | } 861| | } 862| 596| else { 863| 596| const sv str = [&]() -> const sv { 864| 596| if constexpr (array_char_t) { 865| 596| return sv{value.data(), value.size()}; 866| 596| } 867| 596| else if constexpr (u8str_t) { 868| 596| return sv{reinterpret_cast(value.data()), value.size()}; 869| 596| } 870| 596| else { 871| 596| return str_view(value); 872| 596| } 873| 596| }(); 874| 596| const auto n = str.size(); 875| | 876| | // In the case n == 0 we need two characters for quotes. 877| | // For each individual character we need room for two characters to handle escapes. 878| | // When using Unicode escapes, we might need up to 6 characters (\uXXXX) per character 879| | if constexpr (check_escape_control_characters(Opts)) { 880| | // We need 2 + 6 * n characters in the worst case (all control chars) 881| | if (!ensure_space(ctx, b, ix + 10 + 6 * n)) [[unlikely]] { 882| | return; 883| | } 884| | } 885| 596| else { 886| | // Using the original sizing 887| 596| if (!ensure_space(ctx, b, ix + 10 + 2 * n)) [[unlikely]] { ------------------ | Branch (887:23): [True: 0, False: 596] ------------------ 888| 0| return; 889| 0| } 890| 596| } 891| | // now we don't have to check writing 892| | 893| | if constexpr (check_unquoted(Opts)) { 894| | if (n) { 895| | std::memcpy(&b[ix], str.data(), n); 896| | ix += n; 897| | } 898| | } 899| 596| else { 900| 596| std::memcpy(&b[ix], "\"", 1); 901| 596| ++ix; 902| | 903| 596| const auto* c = str.data(); 904| 596| const auto* const e = c + n; 905| 596| const auto start = &b[ix]; 906| 596| auto data = start; 907| | 908| | // By default we don't escape control characters for performance. Invalid JSON characters 909| | // result in null characters in the output, making the JSON invalid — these would then be 910| | // detected upon reading. Enable the `escape_control_characters` option to properly escape 911| | // control characters (0x00–0x1F) as \uXXXX sequences. 912| | 913| | // Escape handler: writes the escaped form of *c into data, advances both pointers 914| 596| auto write_escape = [&]() { 915| 596| if constexpr (check_escape_control_characters(Opts)) { 916| 596| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 917| 596| std::memcpy(data, &escaped, 2); 918| 596| data += 2; 919| 596| } 920| 596| else { 921| 596| char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 922| 596| constexpr char hex_digits[] = "0123456789ABCDEF"; 923| 596| unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 924| 596| unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 925| 596| std::memcpy(data, unicode_escape, 6); 926| 596| data += 6; 927| 596| } 928| 596| } 929| 596| else { 930| 596| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 931| 596| data += 2; 932| 596| } 933| 596| ++c; 934| 596| }; 935| | 936| | // Adding a helper here means adding a branch to string_escape_simd() in 937| | // simd/backends.hpp, which names the widest one this cascade invokes, and a row 938| | // to known_builds in tests/json_test/utf8_validation_test.cpp, which checks it. 939| |#if defined(GLZ_USE_AVX2) 940| | detail::avx2_string_escape(c, e, data, n, write_escape); 941| |#endif 942| 596|#if defined(GLZ_USE_SSE2) 943| 596| detail::sse2_string_escape(c, e, data, n, write_escape); 944| |#elif defined(GLZ_USE_NEON) 945| | detail::neon_string_escape(c, e, data, n, write_escape); 946| |#endif 947| | 948| | // SWAR: 8 bytes at a time 949| 596| if (n > 7) { ------------------ | Branch (949:23): [True: 198, False: 398] ------------------ 950| 412| for (const auto end_m7 = e - 7; c < end_m7;) { ------------------ | Branch (950:54): [True: 214, False: 198] ------------------ 951| 214| std::memcpy(data, c, 8); 952| 214| uint64_t swar; 953| 214| std::memcpy(&swar, c, 8); 954| | if constexpr (std::endian::native == std::endian::big) { 955| | swar = std::byteswap(swar); 956| | } 957| | 958| 214| constexpr uint64_t lo7_mask = repeat_byte8(0b01111111); 959| 214| const uint64_t lo7 = swar & lo7_mask; 960| 214| const uint64_t quote = (lo7 ^ repeat_byte8('"')) + lo7_mask; 961| 214| const uint64_t backslash = (lo7 ^ repeat_byte8('\\')) + lo7_mask; 962| 214| const uint64_t less_32 = (swar & repeat_byte8(0b01100000)) + lo7_mask; 963| 214| uint64_t next = ~((quote & backslash & less_32) | swar); 964| | 965| 214| next &= repeat_byte8(0b10000000); 966| 214| if (next == 0) { ------------------ | Branch (966:29): [True: 99, False: 115] ------------------ 967| 99| data += 8; 968| 99| c += 8; 969| 99| continue; 970| 99| } 971| | 972| 115| const auto length = (countr_zero(next) >> 3); 973| 115| c += length; 974| 115| data += length; 975| 115| write_escape(); 976| 115| } 977| 198| } 978| | 979| | // Scalar tail 980| 1.70k| for (; c < e; ++c) { ------------------ | Branch (980:26): [True: 1.10k, False: 596] ------------------ 981| 1.10k| if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { ------------------ | Branch (981:79): [True: 122, False: 982] ------------------ 982| 122| std::memcpy(data, &escaped, 2); 983| 122| data += 2; 984| 122| } 985| | else if constexpr (check_escape_control_characters(Opts)) { 986| | if (uint8_t(*c) < 0x20) { 987| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 988| | constexpr char hex_digits[] = "0123456789ABCDEF"; 989| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 990| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 991| | std::memcpy(data, unicode_escape, 6); 992| | data += 6; 993| | } 994| | else { 995| | std::memcpy(data, c, 1); 996| | ++data; 997| | } 998| | } 999| 982| else { 1000| 982| std::memcpy(data, c, 1); 1001| 982| ++data; 1002| 982| } 1003| 1.10k| } 1004| | 1005| 596| ix += size_t(data - start); 1006| | 1007| 596| std::memcpy(&b[ix], "\"", 1); 1008| 596| ++ix; 1009| 596| } 1010| 596| } 1011| 596| } 1012| 596| } _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE_clEv: 863| 596| const sv str = [&]() -> const sv { 864| | if constexpr (array_char_t) { 865| | return sv{value.data(), value.size()}; 866| | } 867| | else if constexpr (u8str_t) { 868| | return sv{reinterpret_cast(value.data()), value.size()}; 869| | } 870| 596| else { 871| 596| return str_view(value); 872| 596| } 873| 596| }(); _ZZN3glz2toILj10ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS7_SB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlvE0_clEv: 914| 5.01k| auto write_escape = [&]() { 915| | if constexpr (check_escape_control_characters(Opts)) { 916| | if (const auto escaped = char_escape_table[uint8_t(*c)]; escaped) { 917| | std::memcpy(data, &escaped, 2); 918| | data += 2; 919| | } 920| | else { 921| | char unicode_escape[6] = {'\\', 'u', '0', '0', '0', '0'}; 922| | constexpr char hex_digits[] = "0123456789ABCDEF"; 923| | unicode_escape[4] = hex_digits[(uint8_t(*c) >> 4) & 0xF]; 924| | unicode_escape[5] = hex_digits[uint8_t(*c) & 0xF]; 925| | std::memcpy(data, unicode_escape, 6); 926| | data += 6; 927| | } 928| | } 929| 5.01k| else { 930| 5.01k| std::memcpy(data, &char_escape_table[uint8_t(*c)], 2); 931| 5.01k| data += 2; 932| 5.01k| } 933| 5.01k| ++c; 934| 5.01k| }; _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm2EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2273| 160| { 2274| 160| using ValueType = std::decay_t; 2275| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2276| | constexpr auto& writer = meta_unknown_write_v; 2277| | 2278| | using WriterType = meta_unknown_write_t; 2279| | if constexpr (std::is_member_object_pointer_v) { 2280| | decltype(auto) unknown_writer = value.*writer; 2281| | if (unknown_writer.size() > 0) { 2282| | // TODO: This intermediate is added to get GCC 14 to build 2283| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2284| | serialize::op()>(std::move(merged), ctx, b, ix); 2285| | } 2286| | else { 2287| | serialize::op()>(value, ctx, b, ix); 2288| | } 2289| | } 2290| | else if constexpr (std::is_member_function_pointer_v) { 2291| | decltype(auto) unknown_writer = (value.*writer)(); 2292| | if (unknown_writer.size() > 0) { 2293| | // TODO: This intermediate is added to get GCC 14 to build 2294| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2295| | serialize::op()>(std::move(merged), ctx, b, ix); 2296| | } 2297| | else { 2298| | serialize::op()>(value, ctx, b, ix); 2299| | } 2300| | } 2301| | else { 2302| | static_assert(false_v, "unknown_write type not handled"); 2303| | } 2304| | } 2305| 160| else { 2306| | // handles glaze_object_t without extra unknown fields 2307| 160| static constexpr auto Opts = 2308| 160| disable_write_unknown_off()>()>(); 2309| | 2310| 160| if constexpr (not check_opening_handled(Options)) { 2311| | if constexpr (Options.prettify) { 2312| | ctx.depth += check_indentation_width(Options); 2313| | if constexpr (not check_write_unchecked(Options)) { 2314| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2315| | return; 2316| | } 2317| | } 2318| | std::memcpy(&b[ix], "{\n", 2); 2319| | ix += 2; 2320| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2321| | ix += ctx.depth; 2322| | } 2323| 160| else { 2324| 160| if constexpr (not check_write_unchecked(Options)) { 2325| 160| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2325:26): [True: 0, False: 160] ------------------ 2326| 0| return; 2327| 0| } 2328| 160| } 2329| 160| dump('{', b, ix); 2330| 160| } 2331| 160| } 2332| | 2333| 0| static constexpr auto N = reflect::size; 2334| | 2335| 160| decltype(auto) t = [&]() -> decltype(auto) { 2336| 160| if constexpr (reflectable) { 2337| 160| return to_tie(value); 2338| 160| } 2339| 160| else { 2340| 160| return nullptr; 2341| 160| } 2342| 160| }(); 2343| | 2344| 160| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2345| | if constexpr (maybe_skipped) { 2346| | bool first = true; 2347| | for_each([&]() { 2348| | using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| | else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| | if (is_glaze_value_field_null(value, t)) return; 2406| | } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| | else { 2426| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2427| | return; 2428| | } 2429| | } 2430| | 2431| | if (first) { 2432| | first = false; 2433| | } 2434| | else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| | else { 2443| | std::memcpy(&b[ix], ",", 1); 2444| | ++ix; 2445| | } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| | } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| | static constexpr auto quoted_key = quoted_key_v; 2454| | static constexpr auto n = quoted_key.size(); 2455| | std::memcpy(&b[ix], quoted_key.data(), n); 2456| | ix += n; 2457| | 2458| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2459| | if constexpr (reflectable) { 2460| | to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| | } 2467| | }); 2468| | } 2469| 160| else { 2470| 160| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2470:57): [Folded, False: 160] ------------------ 2471| 160| if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2472| 160| if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { ------------------ | Branch (2472:23): [True: 0, False: 160] ------------------ 2473| 0| return; 2474| 0| } 2475| 160| } 2476| | 2477| 160| for_each([&]() { 2478| 160| if constexpr (write_can_error()) { 2479| 160| if (bool(ctx.error)) [[unlikely]] { 2480| 160| return; 2481| 160| } 2482| 160| } 2483| 160| if constexpr (not fixed_max_size) { 2484| 160| if constexpr (Opts.prettify) { 2485| 160| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| 160| return; 2487| 160| } 2488| 160| } 2489| 160| else { 2490| 160| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| 160| return; 2492| 160| } 2493| 160| } 2494| 160| } 2495| | 2496| 160| if constexpr (I != 0 && Opts.prettify) { 2497| 160| std::memcpy(&b[ix], ",\n", 2); 2498| 160| ix += 2; 2499| 160| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| 160| ix += ctx.depth; 2501| 160| } 2502| | 2503| 160| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 160| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| 160| if constexpr (always_null_t) { 2508| 160| if constexpr (I == 0 || Opts.prettify) { 2509| 160| static constexpr auto quoted_key = join_v, chars<"null">>; 2510| 160| static constexpr auto n = quoted_key.size(); 2511| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2512| 160| ix += n; 2513| 160| } 2514| 160| else { 2515| 160| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| 160| static constexpr auto n = quoted_key.size(); 2517| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2518| 160| ix += n; 2519| 160| } 2520| 160| } 2521| 160| else { 2522| 160| if constexpr (I == 0 || Opts.prettify) { 2523| 160| static constexpr auto quoted_key = quoted_key_v; 2524| 160| static constexpr auto n = quoted_key.size(); 2525| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 160| ix += n; 2527| 160| } 2528| 160| else { 2529| 160| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 160| static constexpr auto n = quoted_key.size(); 2531| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 160| ix += n; 2533| 160| } 2534| | 2535| 160| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2536| 160| if constexpr (reflectable) { 2537| 160| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| 160| } 2539| 160| else { 2540| 160| to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| 160| ix); 2542| 160| } 2543| 160| } 2544| 160| }); 2545| 160| } 2546| | 2547| | // Options is required here, because it must be the top level 2548| 160| if constexpr (not check_closing_handled(Options)) { 2549| | if constexpr (Options.prettify) { 2550| | ctx.depth -= check_indentation_width(Options); 2551| | if constexpr (not check_write_unchecked(Options)) { 2552| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2553| | return; 2554| | } 2555| | } 2556| | std::memcpy(&b[ix], "\n", 1); 2557| | ++ix; 2558| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2559| | ix += ctx.depth; 2560| | std::memcpy(&b[ix], "}", 1); 2561| | ++ix; 2562| | } 2563| 160| else { 2564| 160| dump || check_write_unchecked(Options))>('}', b, ix); 2565| 160| } 2566| 160| } 2567| 160| } 2568| 160| } _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2335| 160| decltype(auto) t = [&]() -> decltype(auto) { 2336| 160| if constexpr (reflectable) { 2337| 160| return to_tie(value); 2338| | } 2339| | else { 2340| | return nullptr; 2341| | } 2342| 160| }(); _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2477| 160| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| | if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| | else { 2490| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| | return; 2492| | } 2493| | } 2494| | } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 160| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 160| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 160| else { 2522| 160| if constexpr (I == 0 || Opts.prettify) { 2523| 160| static constexpr auto quoted_key = quoted_key_v; 2524| 160| static constexpr auto n = quoted_key.size(); 2525| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 160| ix += n; 2527| | } 2528| | else { 2529| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| | static constexpr auto n = quoted_key.size(); 2531| | std::memcpy(&b[ix], quoted_key.data(), n); 2532| | ix += n; 2533| | } 2534| | 2535| 160| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [True: 0, Folded] ------------------ 2536| 160| if constexpr (reflectable) { 2537| 160| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 160| } 2544| 160| }); _ZZN3glz2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2477| 160| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| | if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| | else { 2490| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| | return; 2492| | } 2493| | } 2494| | } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 160| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 160| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 160| else { 2522| | if constexpr (I == 0 || Opts.prettify) { 2523| | static constexpr auto quoted_key = quoted_key_v; 2524| | static constexpr auto n = quoted_key.size(); 2525| | std::memcpy(&b[ix], quoted_key.data(), n); 2526| | ix += n; 2527| | } 2528| 160| else { 2529| 160| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 160| static constexpr auto n = quoted_key.size(); 2531| 160| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 160| ix += n; 2533| 160| } 2534| | 2535| 160| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [True: 0, Folded] ------------------ 2536| 160| if constexpr (reflectable) { 2537| 160| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 160| } 2544| 160| }); _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm3EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_: 2273| 91| { 2274| 91| using ValueType = std::decay_t; 2275| | if constexpr (has_unknown_writer && not check_disable_write_unknown(Options)) { 2276| | constexpr auto& writer = meta_unknown_write_v; 2277| | 2278| | using WriterType = meta_unknown_write_t; 2279| | if constexpr (std::is_member_object_pointer_v) { 2280| | decltype(auto) unknown_writer = value.*writer; 2281| | if (unknown_writer.size() > 0) { 2282| | // TODO: This intermediate is added to get GCC 14 to build 2283| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2284| | serialize::op()>(std::move(merged), ctx, b, ix); 2285| | } 2286| | else { 2287| | serialize::op()>(value, ctx, b, ix); 2288| | } 2289| | } 2290| | else if constexpr (std::is_member_function_pointer_v) { 2291| | decltype(auto) unknown_writer = (value.*writer)(); 2292| | if (unknown_writer.size() > 0) { 2293| | // TODO: This intermediate is added to get GCC 14 to build 2294| | decltype(auto) merged = glz::merge{value, unknown_writer}; 2295| | serialize::op()>(std::move(merged), ctx, b, ix); 2296| | } 2297| | else { 2298| | serialize::op()>(value, ctx, b, ix); 2299| | } 2300| | } 2301| | else { 2302| | static_assert(false_v, "unknown_write type not handled"); 2303| | } 2304| | } 2305| 91| else { 2306| | // handles glaze_object_t without extra unknown fields 2307| 91| static constexpr auto Opts = 2308| 91| disable_write_unknown_off()>()>(); 2309| | 2310| 91| if constexpr (not check_opening_handled(Options)) { 2311| | if constexpr (Options.prettify) { 2312| | ctx.depth += check_indentation_width(Options); 2313| | if constexpr (not check_write_unchecked(Options)) { 2314| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2315| | return; 2316| | } 2317| | } 2318| | std::memcpy(&b[ix], "{\n", 2); 2319| | ix += 2; 2320| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2321| | ix += ctx.depth; 2322| | } 2323| 91| else { 2324| 91| if constexpr (not check_write_unchecked(Options)) { 2325| 91| if (!ensure_space(ctx, b, ix + 1)) [[unlikely]] { ------------------ | Branch (2325:26): [True: 0, False: 91] ------------------ 2326| 0| return; 2327| 0| } 2328| 91| } 2329| 91| dump('{', b, ix); 2330| 91| } 2331| 91| } 2332| | 2333| 0| static constexpr auto N = reflect::size; 2334| | 2335| 91| decltype(auto) t = [&]() -> decltype(auto) { 2336| 91| if constexpr (reflectable) { 2337| 91| return to_tie(value); 2338| 91| } 2339| 91| else { 2340| 91| return nullptr; 2341| 91| } 2342| 91| }(); 2343| | 2344| 91| static constexpr auto padding = round_up_to_nearest_16(maximum_key_size + write_padding_bytes); 2345| | if constexpr (maybe_skipped) { 2346| | bool first = true; 2347| | for_each([&]() { 2348| | using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| | constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| | else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| | if (is_glaze_value_field_null(value, t)) return; 2406| | } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| | else { 2426| | if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2427| | return; 2428| | } 2429| | } 2430| | 2431| | if (first) { 2432| | first = false; 2433| | } 2434| | else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| | else { 2443| | std::memcpy(&b[ix], ",", 1); 2444| | ++ix; 2445| | } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| | } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| | static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| | static constexpr auto quoted_key = quoted_key_v; 2454| | static constexpr auto n = quoted_key.size(); 2455| | std::memcpy(&b[ix], quoted_key.data(), n); 2456| | ix += n; 2457| | 2458| | static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2459| | if constexpr (reflectable) { 2460| | to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| | } 2467| | }); 2468| | } 2469| 91| else { 2470| 91| static constexpr size_t fixed_max_size = Opts.prettify ? 0 : fixed_padding; ------------------ | Branch (2470:57): [Folded, False: 91] ------------------ 2471| | if constexpr (fixed_max_size && not check_write_unchecked(Options)) { 2472| | if (!ensure_space(ctx, b, ix + fixed_max_size)) [[unlikely]] { 2473| | return; 2474| | } 2475| | } 2476| | 2477| 91| for_each([&]() { 2478| 91| if constexpr (write_can_error()) { 2479| 91| if (bool(ctx.error)) [[unlikely]] { 2480| 91| return; 2481| 91| } 2482| 91| } 2483| 91| if constexpr (not fixed_max_size) { 2484| 91| if constexpr (Opts.prettify) { 2485| 91| if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| 91| return; 2487| 91| } 2488| 91| } 2489| 91| else { 2490| 91| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { 2491| 91| return; 2492| 91| } 2493| 91| } 2494| 91| } 2495| | 2496| 91| if constexpr (I != 0 && Opts.prettify) { 2497| 91| std::memcpy(&b[ix], ",\n", 2); 2498| 91| ix += 2; 2499| 91| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| 91| ix += ctx.depth; 2501| 91| } 2502| | 2503| 91| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 91| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| 91| if constexpr (always_null_t) { 2508| 91| if constexpr (I == 0 || Opts.prettify) { 2509| 91| static constexpr auto quoted_key = join_v, chars<"null">>; 2510| 91| static constexpr auto n = quoted_key.size(); 2511| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2512| 91| ix += n; 2513| 91| } 2514| 91| else { 2515| 91| static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| 91| static constexpr auto n = quoted_key.size(); 2517| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2518| 91| ix += n; 2519| 91| } 2520| 91| } 2521| 91| else { 2522| 91| if constexpr (I == 0 || Opts.prettify) { 2523| 91| static constexpr auto quoted_key = quoted_key_v; 2524| 91| static constexpr auto n = quoted_key.size(); 2525| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 91| ix += n; 2527| 91| } 2528| 91| else { 2529| 91| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 91| static constexpr auto n = quoted_key.size(); 2531| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 91| ix += n; 2533| 91| } 2534| | 2535| 91| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; 2536| 91| if constexpr (reflectable) { 2537| 91| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| 91| } 2539| 91| else { 2540| 91| to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| 91| ix); 2542| 91| } 2543| 91| } 2544| 91| }); 2545| 91| } 2546| | 2547| | // Options is required here, because it must be the top level 2548| 91| if constexpr (not check_closing_handled(Options)) { 2549| | if constexpr (Options.prettify) { 2550| | ctx.depth -= check_indentation_width(Options); 2551| | if constexpr (not check_write_unchecked(Options)) { 2552| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 2553| | return; 2554| | } 2555| | } 2556| | std::memcpy(&b[ix], "\n", 1); 2557| | ++ix; 2558| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2559| | ix += ctx.depth; 2560| | std::memcpy(&b[ix], "}", 1); 2561| | ++ix; 2562| | } 2563| 91| else { 2564| 91| dump || check_write_unchecked(Options))>('}', b, ix); 2565| 91| } 2566| 91| } 2567| 91| } 2568| 91| } _ZZN3glz2toILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlvE_clEv: 2335| 91| decltype(auto) t = [&]() -> decltype(auto) { 2336| 91| if constexpr (reflectable) { 2337| 91| return to_tie(value); 2338| | } 2339| | else { 2340| | return nullptr; 2341| | } 2342| 91| }(); _ZZN3glz2toILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm0EEEDav: 2477| 91| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| 91| if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| 91| else { 2490| 91| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2490:29): [True: 0, False: 91] ------------------ 2491| 0| return; 2492| 0| } 2493| 91| } 2494| 91| } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 91| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 91| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 91| else { 2522| 91| if constexpr (I == 0 || Opts.prettify) { 2523| 91| static constexpr auto quoted_key = quoted_key_v; 2524| 91| static constexpr auto n = quoted_key.size(); 2525| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2526| 91| ix += n; 2527| | } 2528| | else { 2529| | static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| | static constexpr auto n = quoted_key.size(); 2531| | std::memcpy(&b[ix], quoted_key.data(), n); 2532| | ix += n; 2533| | } 2534| | 2535| 91| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [True: 0, Folded] ------------------ 2536| 91| if constexpr (reflectable) { 2537| 91| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 91| } 2544| 91| }); _ZZN3glz2toILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm1EEEDav: 2477| 91| for_each([&]() { 2478| | if constexpr (write_can_error()) { 2479| | if (bool(ctx.error)) [[unlikely]] { 2480| | return; 2481| | } 2482| | } 2483| 91| if constexpr (not fixed_max_size) { 2484| | if constexpr (Opts.prettify) { 2485| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2486| | return; 2487| | } 2488| | } 2489| 91| else { 2490| 91| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2490:29): [True: 0, False: 91] ------------------ 2491| 0| return; 2492| 0| } 2493| 91| } 2494| 91| } 2495| | 2496| | if constexpr (I != 0 && Opts.prettify) { 2497| | std::memcpy(&b[ix], ",\n", 2); 2498| | ix += 2; 2499| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2500| | ix += ctx.depth; 2501| | } 2502| | 2503| 91| using val_t = field_t; 2504| | 2505| | // MSVC requires get rather than keys[I] 2506| 91| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2507| | if constexpr (always_null_t) { 2508| | if constexpr (I == 0 || Opts.prettify) { 2509| | static constexpr auto quoted_key = join_v, chars<"null">>; 2510| | static constexpr auto n = quoted_key.size(); 2511| | std::memcpy(&b[ix], quoted_key.data(), n); 2512| | ix += n; 2513| | } 2514| | else { 2515| | static constexpr auto quoted_key = join_v, quoted_key_v, chars<"null">>; 2516| | static constexpr auto n = quoted_key.size(); 2517| | std::memcpy(&b[ix], quoted_key.data(), n); 2518| | ix += n; 2519| | } 2520| | } 2521| 91| else { 2522| | if constexpr (I == 0 || Opts.prettify) { 2523| | static constexpr auto quoted_key = quoted_key_v; 2524| | static constexpr auto n = quoted_key.size(); 2525| | std::memcpy(&b[ix], quoted_key.data(), n); 2526| | ix += n; 2527| | } 2528| 91| else { 2529| 91| static constexpr auto quoted_key = join_v, quoted_key_v>; 2530| 91| static constexpr auto n = quoted_key.size(); 2531| 91| std::memcpy(&b[ix], quoted_key.data(), n); 2532| 91| ix += n; 2533| 91| } 2534| | 2535| 91| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2535:57): [Folded, False: 91] ------------------ 2536| 91| if constexpr (reflectable) { 2537| 91| to::template op(get_member(value, get(t)), ctx, b, ix); 2538| | } 2539| | else { 2540| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2541| | ix); 2542| | } 2543| 91| } 2544| 91| }); _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm4EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _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_: 1234| 91| { 1235| 91| if (empty_range(value)) { ------------------ | Branch (1235:14): [True: 91, False: 0] ------------------ 1236| 91| dump("[]", b, ix); 1237| 91| } 1238| 0| else { 1239| | // For bounded buffers, skip pre-allocation path since value_padding is for SIMD, not actual size 1240| 0| if constexpr (has_size && array_padding_known && !has_bounded_capacity) { 1241| 0| const auto n = value.size(); 1242| | 1243| 0| static constexpr auto value_padding = []() -> size_t { 1244| 0| if constexpr (required_padding() > 0) 1245| 0| return required_padding(); 1246| 0| else 1247| 0| return fixed_padding; 1248| 0| }(); 1249| | 1250| | if constexpr (Opts.prettify) { 1251| | if constexpr (check_new_lines_in_arrays(Opts)) { 1252| | ctx.depth += check_indentation_width(Opts); 1253| | } 1254| | 1255| | // add space for '\n' and ',' characters for each element, hence `+ 2` 1256| | // use n + 1 because we put the end array character after the last element with whitespace 1257| | if (!ensure_space(ctx, b, ix + (n + 1) * (value_padding + ctx.depth + 2) + write_padding_bytes)) 1258| | [[unlikely]] { 1259| | return; 1260| | } 1261| | 1262| | if constexpr (check_new_lines_in_arrays(Opts)) { 1263| | std::memcpy(&b[ix], "[\n", 2); 1264| | ix += 2; 1265| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1266| | ix += ctx.depth; 1267| | } 1268| | else { 1269| | std::memcpy(&b[ix], "[", 1); 1270| | ++ix; 1271| | } 1272| | } 1273| 0| else { 1274| 0| static constexpr auto comma_padding = 1; 1275| 0| if (!ensure_space(ctx, b, ix + n * (value_padding + comma_padding) + write_padding_bytes)) ------------------ | Branch (1275:23): [True: 0, False: 0] ------------------ 1276| 0| [[unlikely]] { 1277| 0| return; 1278| 0| } 1279| 0| std::memcpy(&b[ix], "[", 1); 1280| 0| ++ix; 1281| 0| } 1282| | 1283| 0| auto it = std::begin(value); 1284| 0| using val_t = std::remove_cvref_t; 1285| 0| to::template op()>(*it, ctx, b, ix); 1286| | 1287| 0| ++it; 1288| 0| for (const auto fin = std::end(value); it != fin; ++it) { ------------------ | Branch (1288:55): [True: 0, False: 0] ------------------ 1289| | if constexpr (Opts.prettify) { 1290| | if constexpr (check_new_lines_in_arrays(Opts)) { 1291| | std::memcpy(&b[ix], ",\n", 2); 1292| | ix += 2; 1293| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1294| | ix += ctx.depth; 1295| | } 1296| | else { 1297| | std::memcpy(&b[ix], ", ", 2); 1298| | ix += 2; 1299| | } 1300| | } 1301| 0| else { 1302| 0| std::memcpy(&b[ix], ",", 1); 1303| 0| ++ix; 1304| 0| } 1305| | if constexpr (is_output_streaming) { 1306| | flush_buffer(b, ix); 1307| | } 1308| | 1309| 0| to::template op()>(*it, ctx, b, ix); 1310| 0| } 1311| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1312| | ctx.depth -= check_indentation_width(Opts); 1313| | std::memcpy(&b[ix], "\n", 1); 1314| | ++ix; 1315| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1316| | ix += ctx.depth; 1317| | } 1318| | 1319| 0| std::memcpy(&b[ix], "]", 1); 1320| 0| ++ix; 1321| | } 1322| | else { 1323| | // we either can't get the size (std::forward_list) or we cannot compute the allocation size 1324| | 1325| | if constexpr (Opts.prettify) { 1326| | if constexpr (check_new_lines_in_arrays(Opts)) { 1327| | ctx.depth += check_indentation_width(Opts); 1328| | } 1329| | 1330| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1331| | return; 1332| | } 1333| | 1334| | if constexpr (check_new_lines_in_arrays(Opts)) { 1335| | std::memcpy(&b[ix], "[\n", 2); 1336| | ix += 2; 1337| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1338| | ix += ctx.depth; 1339| | } 1340| | else { 1341| | std::memcpy(&b[ix], "[", 1); 1342| | ++ix; 1343| | } 1344| | } 1345| | else { 1346| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1347| | return; 1348| | } 1349| | std::memcpy(&b[ix], "[", 1); 1350| | ++ix; 1351| | } 1352| | 1353| | auto it = std::begin(value); 1354| | using val_t = std::remove_cvref_t; 1355| | if constexpr (required_padding()) { 1356| | to::template op()>(*it, ctx, b, ix); 1357| | } 1358| | else { 1359| | to::template op(*it, ctx, b, ix); 1360| | if (bool(ctx.error)) [[unlikely]] { 1361| | return; 1362| | } 1363| | } 1364| | 1365| | ++it; 1366| | for (const auto fin = std::end(value); it != fin; ++it) { 1367| | if constexpr (required_padding()) { 1368| | if constexpr (Opts.prettify) { 1369| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1370| | return; 1371| | } 1372| | } 1373| | else { 1374| | if (!ensure_space(ctx, b, ix + write_padding_bytes)) [[unlikely]] { 1375| | return; 1376| | } 1377| | } 1378| | 1379| | if constexpr (Opts.prettify) { 1380| | if constexpr (check_new_lines_in_arrays(Opts)) { 1381| | std::memcpy(&b[ix], ",\n", 2); 1382| | ix += 2; 1383| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1384| | ix += ctx.depth; 1385| | } 1386| | else { 1387| | std::memcpy(&b[ix], ", ", 2); 1388| | ix += 2; 1389| | } 1390| | } 1391| | else { 1392| | std::memcpy(&b[ix], ",", 1); 1393| | ++ix; 1394| | } 1395| | if constexpr (is_output_streaming) { 1396| | flush_buffer(b, ix); 1397| | } 1398| | 1399| | to::template op()>(*it, ctx, b, ix); 1400| | } 1401| | else { 1402| | write_array_entry_separator(ctx, b, ix); 1403| | to::template op(*it, ctx, b, ix); 1404| | if (bool(ctx.error)) [[unlikely]] { 1405| | return; 1406| | } 1407| | } 1408| | } 1409| | if constexpr (Opts.prettify && check_new_lines_in_arrays(Opts)) { 1410| | ctx.depth -= check_indentation_width(Opts); 1411| | dump_newline_indent(check_indentation_char(Opts), ctx.depth, b, ix); 1412| | } 1413| | 1414| | dump(']', b, ix); 1415| | } 1416| 0| } 1417| 91| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm5EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _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_: 1422| 91| { 1423| 91| if constexpr (not check_opening_handled(Opts)) { 1424| 91| dump('{', b, ix); 1425| 91| } 1426| | 1427| 91| if (!empty_range(value)) { ------------------ | Branch (1427:14): [True: 0, False: 91] ------------------ 1428| 0| if constexpr (!check_opening_handled(Opts)) { 1429| | if constexpr (Opts.prettify) { 1430| | ctx.depth += check_indentation_width(Opts); 1431| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1432| | return; 1433| | } 1434| | std::memcpy(&b[ix], "\n", 1); 1435| | ++ix; 1436| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1437| | ix += ctx.depth; 1438| | } 1439| 0| } 1440| | 1441| 0| using val_t = detail::iterator_second_type; // the type of value in each [key, value] pair 1442| 0| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 1443| 0| if constexpr (!always_skipped && (write_function_pointers || !is_any_function_ptr)) { 1444| | if constexpr (null_t && Opts.skip_null_members) { 1445| | auto write_first_entry = [&](auto&& it) { 1446| | auto&& [key, entry_val] = *it; 1447| | if (skip_member(entry_val)) { 1448| | return true; 1449| | } 1450| | write_pair_content(key, entry_val, ctx, b, ix); 1451| | return bool(ctx.error); 1452| | }; 1453| | 1454| | auto it = std::begin(value); 1455| | bool first = write_first_entry(it); 1456| | if (bool(ctx.error)) [[unlikely]] { 1457| | return; 1458| | } 1459| | ++it; 1460| | for (const auto end = std::end(value); it != end; ++it) { 1461| | auto&& [key, entry_val] = *it; 1462| | if (skip_member(entry_val)) { 1463| | continue; 1464| | } 1465| | 1466| | // When Opts.skip_null_members, *any* entry may be skipped, meaning separator dumping must be 1467| | // conditional for every entry. 1468| | // Alternatively, write separator after each entry except last but then branch is permanent 1469| | if (not first) { 1470| | write_object_entry_separator(ctx, b, ix); 1471| | } 1472| | 1473| | write_pair_content(key, entry_val, ctx, b, ix); 1474| | if (bool(ctx.error)) [[unlikely]] { 1475| | return; 1476| | } 1477| | 1478| | first = false; 1479| | } 1480| | } 1481| 0| else { 1482| 0| auto write_first_entry = [&](auto&& it) { 1483| 0| auto&& [key, entry_val] = *it; 1484| 0| write_pair_content(key, entry_val, ctx, b, ix); 1485| 0| }; 1486| | 1487| 0| auto it = std::begin(value); 1488| 0| write_first_entry(it); 1489| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1489:23): [True: 0, False: 0] ------------------ 1490| 0| return; 1491| 0| } 1492| 0| ++it; 1493| 0| for (const auto end = std::end(value); it != end; ++it) { ------------------ | Branch (1493:58): [True: 0, False: 0] ------------------ 1494| 0| auto&& [key, entry_val] = *it; 1495| 0| write_object_entry_separator(ctx, b, ix); 1496| 0| write_pair_content(key, entry_val, ctx, b, ix); 1497| 0| if (bool(ctx.error)) [[unlikely]] { ------------------ | Branch (1497:26): [True: 0, False: 0] ------------------ 1498| 0| return; 1499| 0| } 1500| 0| } 1501| 0| } 1502| 0| } 1503| | 1504| 0| if constexpr (!check_closing_handled(Opts)) { 1505| | if constexpr (Opts.prettify) { 1506| | ctx.depth -= check_indentation_width(Opts); 1507| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1508| | return; 1509| | } 1510| | std::memcpy(&b[ix], "\n", 1); 1511| | ++ix; 1512| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1513| | ix += ctx.depth; 1514| | } 1515| 0| } 1516| 0| } 1517| | 1518| 91| if constexpr (!check_closing_handled(Opts)) { 1519| 91| dump('}', b, ix); 1520| 91| } 1521| 91| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| 47| if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| 47| else { 2377| 47| const auto is_null = [&]() { 2378| 47| decltype(auto) element = [&]() -> decltype(auto) { 2379| 47| if constexpr (reflectable) { 2380| 47| return get(t); 2381| 47| } 2382| 47| else { 2383| 47| return get(reflect::values); 2384| 47| } 2385| 47| }; 2386| | 2387| 47| if constexpr (nullable_wrapper) { 2388| 47| return !bool(element()(value).val); 2389| 47| } 2390| 47| else if constexpr (nullable_value_t) { 2391| 47| return !get_member(value, element()).has_value(); 2392| 47| } 2393| 47| else { 2394| 47| return !bool(get_member(value, element())); 2395| 47| } 2396| 47| }(); 2397| 47| if (is_null) return; ------------------ | Branch (2397:32): [True: 47, False: 0] ------------------ 2398| 47| } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| | else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| | if (is_glaze_value_field_null(value, t)) return; 2406| | } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [True: 0, Folded] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm6EEEDavENKUlvE_clEv: 2377| 47| const auto is_null = [&]() { 2378| 47| decltype(auto) element = [&]() -> decltype(auto) { 2379| 47| if constexpr (reflectable) { 2380| 47| return get(t); 2381| 47| } 2382| 47| else { 2383| 47| return get(reflect::values); 2384| 47| } 2385| 47| }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| 47| else if constexpr (nullable_value_t) { 2391| 47| return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| 47| }(); _ZZZZN3glz2toILj10EN9repe_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: 2378| 47| decltype(auto) element = [&]() -> decltype(auto) { 2379| 47| if constexpr (reflectable) { 2380| 47| return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| 47| }; _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm7EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1755| 91| { 1756| | // Adjacent tagging needs no per-alternative dispatch: the discriminator and the value are 1757| | // written side by side whatever the alternative is. The visit below still instantiates in 1758| | // that mode (`if constexpr` does not discard the statements after it), but both of its 1759| | // tagged branches are compile-time dead there and the runtime `return` keeps it unreached. 1760| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::adjacent) { 1761| | write_adjacent(value, ctx, b, ix); 1762| | return; 1763| | } 1764| 91| std::visit( 1765| 91| [&](auto&& val) { 1766| 91| using V = std::decay_t; 1767| | 1768| 91| if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1769| 91| custom_write) { 1770| | // Custom alternative: the user's serializer emits the object body, into which we 1771| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1772| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1773| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1774| | // scalar/array, or that ignores those flags, would yield malformed output. 1775| | // 1776| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1777| | // two in sync. The body size is not known at compile time, so we always write the 1778| | // tag separator and then drop it at runtime if the body turned out empty. 1779| 91| if (missing_id(value, ctx)) { 1780| 91| return; 1781| 91| } 1782| 91| using id_type = std::decay_t[value.index()])>; 1783| 91| if constexpr (Opts.prettify) { 1784| 91| dump("{\n", b, ix); 1785| 91| ctx.depth += check_indentation_width(Opts); 1786| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1787| 91| dump('"', b, ix); 1788| 91| dump_maybe_empty(tag_v, b, ix); 1789| 91| if constexpr (std::integral) { 1790| 91| dump("\": ", b, ix); 1791| 91| serialize::op(ids_v[value.index()], ctx, b, ix); 1792| 91| } 1793| 91| else { 1794| 91| dump("\": \"", b, ix); 1795| 91| dump_maybe_empty(ids_v[value.index()], b, ix); 1796| 91| dump('"', b, ix); 1797| 91| } 1798| 91| const auto pos_after_tag = ix; 1799| 91| dump(",\n", b, ix); 1800| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1801| 91| const auto pos_body_start = ix; 1802| 91| to::template op()>(val, ctx, b, ix); 1803| 91| if (ix == pos_body_start) { 1804| 91| ix = pos_after_tag; // custom body was empty: undo the tag separator 1805| 91| } 1806| 91| ctx.depth -= check_indentation_width(Opts); 1807| 91| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1808| 91| return; 1809| 91| } 1810| 91| std::memcpy(&b[ix], "\n", 1); 1811| 91| ++ix; 1812| 91| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1813| 91| ix += ctx.depth; 1814| 91| std::memcpy(&b[ix], "}", 1); 1815| 91| ++ix; 1816| 91| } 1817| 91| else { 1818| 91| dump("{\"", b, ix); 1819| 91| dump_maybe_empty(tag_v, b, ix); 1820| 91| if constexpr (std::integral) { 1821| 91| dump("\":", b, ix); 1822| 91| serialize::op(ids_v[value.index()], ctx, b, ix); 1823| 91| } 1824| 91| else { 1825| 91| dump("\":\"", b, ix); 1826| 91| dump_maybe_empty(ids_v[value.index()], b, ix); 1827| 91| dump('"', b, ix); 1828| 91| } 1829| 91| const auto pos_after_tag = ix; 1830| 91| dump(',', b, ix); 1831| 91| const auto pos_body_start = ix; 1832| 91| to::template op()>(val, ctx, b, ix); 1833| 91| if (ix == pos_body_start) { 1834| 91| ix = pos_after_tag; // custom body was empty: undo the tag separator 1835| 91| } 1836| 91| dump('}', b, ix); 1837| 91| } 1838| 91| } 1839| 91| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1840| 91| variant_unit_alternative) { 1841| | // A unit alternative carries no data, so internal tagging renders it as the 1842| | // discriminator alone -- the same object an empty struct alternative produces. 1843| 91| if (missing_id(value, ctx)) { 1844| 91| return; 1845| 91| } 1846| 91| if constexpr (Opts.prettify) { 1847| 91| dump("{\n", b, ix); 1848| 91| ctx.depth += check_indentation_width(Opts); 1849| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1850| 91| dump('"', b, ix); 1851| 91| dump_maybe_empty(tag_v, b, ix); 1852| 91| dump("\": ", b, ix); 1853| 91| write_id(value, ctx, b, ix); 1854| 91| ctx.depth -= check_indentation_width(Opts); 1855| 91| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1856| 91| return; 1857| 91| } 1858| 91| std::memcpy(&b[ix], "\n", 1); 1859| 91| ++ix; 1860| 91| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1861| 91| ix += ctx.depth; 1862| 91| std::memcpy(&b[ix], "}", 1); 1863| 91| ++ix; 1864| 91| } 1865| 91| else { 1866| 91| dump("{\"", b, ix); 1867| 91| dump_maybe_empty(tag_v, b, ix); 1868| 91| dump("\":", b, ix); 1869| 91| write_id(value, ctx, b, ix); 1870| 91| dump('}', b, ix); 1871| 91| } 1872| 91| } 1873| 91| else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1874| 91| (glaze_object_t || reflectable || is_memory_object) && 1875| 91| (not alternative_declares_key(tag_v))) { 1876| | // An alternative that declares a member named like the discriminator carries the 1877| | // discriminator itself, so no tag is merged here and the bare-write branch below 1878| | // handles it. Previously only `reflectable` alternatives were excluded; a 1879| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 1880| 91| if (missing_id(value, ctx)) { 1881| 91| return; 1882| 91| } 1883| 91| constexpr auto N = []() { 1884| 91| if constexpr (is_memory_object) { 1885| 91| return reflect>::size; 1886| 91| } 1887| 91| else { 1888| 91| return reflect::size; 1889| 91| } 1890| 91| }(); 1891| | 1892| | // must first write out type 1893| 91| if constexpr (Opts.prettify) { 1894| 91| dump("{\n", b, ix); 1895| 91| ctx.depth += check_indentation_width(Opts); 1896| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1897| 91| dump('"', b, ix); 1898| 91| dump_maybe_empty(tag_v, b, ix); 1899| | 1900| 91| using id_type = std::decay_t[value.index()])>; 1901| | 1902| 91| if constexpr (std::integral) { 1903| 91| dump("\": ", b, ix); 1904| 91| serialize::op(ids_v[value.index()], ctx, b, ix); 1905| 91| if constexpr (N > 0) { 1906| 91| dump(",\n", b, ix); 1907| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1908| 91| } 1909| 91| } 1910| 91| else { 1911| 91| dump("\": \"", b, ix); 1912| 91| dump_maybe_empty(ids_v[value.index()], b, ix); 1913| 91| if constexpr (N == 0) { 1914| 91| dump('"', b, ix); 1915| 91| } 1916| 91| else { 1917| 91| dump("\",\n", b, ix); 1918| 91| dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1919| 91| } 1920| 91| } 1921| 91| } 1922| 91| else { 1923| 91| using id_type = std::decay_t[value.index()])>; 1924| | 1925| 91| dump("{\"", b, ix); 1926| 91| dump_maybe_empty(tag_v, b, ix); 1927| | 1928| 91| if constexpr (std::integral) { 1929| 91| dump("\":", b, ix); 1930| 91| serialize::op(ids_v[value.index()], ctx, b, ix); 1931| 91| if constexpr (N > 0) { 1932| 91| dump(',', b, ix); 1933| 91| } 1934| 91| } 1935| 91| else { 1936| 91| dump("\":\"", b, ix); 1937| 91| dump_maybe_empty(ids_v[value.index()], b, ix); 1938| 91| if constexpr (N == 0) { 1939| 91| dump('"', b, ix); 1940| 91| } 1941| 91| else { 1942| 91| dump("\",", b, ix); 1943| 91| } 1944| 91| } 1945| 91| } 1946| 91| if constexpr (is_memory_object) { 1947| 91| if (!val) [[unlikely]] { 1948| 91| ctx.error = error_code::invalid_variant_object; 1949| 91| return; 1950| 91| } 1951| 91| to>::template op()>(*val, ctx, b, ix); 1952| 91| } 1953| 91| else { 1954| 91| to::template op()>(val, ctx, b, ix); 1955| 91| } 1956| | // If we skip everything then we may have an extra comma, which we want to revert 1957| 91| if constexpr (Opts.skip_null_members) { 1958| 91| if (b[ix - 1] == ',') { 1959| 91| --ix; 1960| 91| } 1961| 91| } 1962| | 1963| 91| if constexpr (Opts.prettify) { 1964| 91| ctx.depth -= check_indentation_width(Opts); 1965| 91| if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1966| 91| return; 1967| 91| } 1968| 91| std::memcpy(&b[ix], "\n", 1); 1969| 91| ++ix; 1970| 91| std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1971| 91| ix += ctx.depth; 1972| 91| std::memcpy(&b[ix], "}", 1); 1973| 91| ++ix; 1974| 91| } 1975| 91| else { 1976| 91| dump('}', b, ix); 1977| 91| } 1978| 91| } 1979| 91| else { 1980| 91| to::template op(val, ctx, b, ix); 1981| 91| } 1982| 91| }, 1983| 91| value); 1984| 91| } _ZZN3glz2toILj10ENSt3__17variantIJNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_fuzz6amountEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSB_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_ENKUlOT_E_clISF_EEDaSS_: 1765| 91| [&](auto&& val) { 1766| 91| using V = std::decay_t; 1767| | 1768| | if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1769| | custom_write) { 1770| | // Custom alternative: the user's serializer emits the object body, into which we 1771| | // merge the variant tag. For this to produce valid JSON the custom to<> must (1) 1772| | // write an object body and (2) honor opening_and_closing_handled (suppress its own 1773| | // braces) so the tag shares the alternative's object. A custom writer that emits a 1774| | // scalar/array, or that ignores those flags, would yield malformed output. 1775| | // 1776| | // The tag-emission below mirrors the reflected-object branch that follows; keep the 1777| | // two in sync. The body size is not known at compile time, so we always write the 1778| | // tag separator and then drop it at runtime if the body turned out empty. 1779| | if (missing_id(value, ctx)) { 1780| | return; 1781| | } 1782| | using id_type = std::decay_t[value.index()])>; 1783| | if constexpr (Opts.prettify) { 1784| | dump("{\n", b, ix); 1785| | ctx.depth += check_indentation_width(Opts); 1786| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1787| | dump('"', b, ix); 1788| | dump_maybe_empty(tag_v, b, ix); 1789| | if constexpr (std::integral) { 1790| | dump("\": ", b, ix); 1791| | serialize::op(ids_v[value.index()], ctx, b, ix); 1792| | } 1793| | else { 1794| | dump("\": \"", b, ix); 1795| | dump_maybe_empty(ids_v[value.index()], b, ix); 1796| | dump('"', b, ix); 1797| | } 1798| | const auto pos_after_tag = ix; 1799| | dump(",\n", b, ix); 1800| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1801| | const auto pos_body_start = ix; 1802| | to::template op()>(val, ctx, b, ix); 1803| | if (ix == pos_body_start) { 1804| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1805| | } 1806| | ctx.depth -= check_indentation_width(Opts); 1807| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1808| | return; 1809| | } 1810| | std::memcpy(&b[ix], "\n", 1); 1811| | ++ix; 1812| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1813| | ix += ctx.depth; 1814| | std::memcpy(&b[ix], "}", 1); 1815| | ++ix; 1816| | } 1817| | else { 1818| | dump("{\"", b, ix); 1819| | dump_maybe_empty(tag_v, b, ix); 1820| | if constexpr (std::integral) { 1821| | dump("\":", b, ix); 1822| | serialize::op(ids_v[value.index()], ctx, b, ix); 1823| | } 1824| | else { 1825| | dump("\":\"", b, ix); 1826| | dump_maybe_empty(ids_v[value.index()], b, ix); 1827| | dump('"', b, ix); 1828| | } 1829| | const auto pos_after_tag = ix; 1830| | dump(',', b, ix); 1831| | const auto pos_body_start = ix; 1832| | to::template op()>(val, ctx, b, ix); 1833| | if (ix == pos_body_start) { 1834| | ix = pos_after_tag; // custom body was empty: undo the tag separator 1835| | } 1836| | dump('}', b, ix); 1837| | } 1838| | } 1839| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1840| | variant_unit_alternative) { 1841| | // A unit alternative carries no data, so internal tagging renders it as the 1842| | // discriminator alone -- the same object an empty struct alternative produces. 1843| | if (missing_id(value, ctx)) { 1844| | return; 1845| | } 1846| | if constexpr (Opts.prettify) { 1847| | dump("{\n", b, ix); 1848| | ctx.depth += check_indentation_width(Opts); 1849| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1850| | dump('"', b, ix); 1851| | dump_maybe_empty(tag_v, b, ix); 1852| | dump("\": ", b, ix); 1853| | write_id(value, ctx, b, ix); 1854| | ctx.depth -= check_indentation_width(Opts); 1855| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1856| | return; 1857| | } 1858| | std::memcpy(&b[ix], "\n", 1); 1859| | ++ix; 1860| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1861| | ix += ctx.depth; 1862| | std::memcpy(&b[ix], "}", 1); 1863| | ++ix; 1864| | } 1865| | else { 1866| | dump("{\"", b, ix); 1867| | dump_maybe_empty(tag_v, b, ix); 1868| | dump("\":", b, ix); 1869| | write_id(value, ctx, b, ix); 1870| | dump('}', b, ix); 1871| | } 1872| | } 1873| | else if constexpr (check_write_type_info(Opts) && tagging == variant_tagging_kind::internal && 1874| | (glaze_object_t || reflectable || is_memory_object) && 1875| | (not alternative_declares_key(tag_v))) { 1876| | // An alternative that declares a member named like the discriminator carries the 1877| | // discriminator itself, so no tag is merged here and the bare-write branch below 1878| | // handles it. Previously only `reflectable` alternatives were excluded; a 1879| | // `glaze_object_t` one fell through to this branch and emitted the key twice. 1880| | if (missing_id(value, ctx)) { 1881| | return; 1882| | } 1883| | constexpr auto N = []() { 1884| | if constexpr (is_memory_object) { 1885| | return reflect>::size; 1886| | } 1887| | else { 1888| | return reflect::size; 1889| | } 1890| | }(); 1891| | 1892| | // must first write out type 1893| | if constexpr (Opts.prettify) { 1894| | dump("{\n", b, ix); 1895| | ctx.depth += check_indentation_width(Opts); 1896| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1897| | dump('"', b, ix); 1898| | dump_maybe_empty(tag_v, b, ix); 1899| | 1900| | using id_type = std::decay_t[value.index()])>; 1901| | 1902| | if constexpr (std::integral) { 1903| | dump("\": ", b, ix); 1904| | serialize::op(ids_v[value.index()], ctx, b, ix); 1905| | if constexpr (N > 0) { 1906| | dump(",\n", b, ix); 1907| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1908| | } 1909| | } 1910| | else { 1911| | dump("\": \"", b, ix); 1912| | dump_maybe_empty(ids_v[value.index()], b, ix); 1913| | if constexpr (N == 0) { 1914| | dump('"', b, ix); 1915| | } 1916| | else { 1917| | dump("\",\n", b, ix); 1918| | dumpn(check_indentation_char(Opts), ctx.depth, b, ix); 1919| | } 1920| | } 1921| | } 1922| | else { 1923| | using id_type = std::decay_t[value.index()])>; 1924| | 1925| | dump("{\"", b, ix); 1926| | dump_maybe_empty(tag_v, b, ix); 1927| | 1928| | if constexpr (std::integral) { 1929| | dump("\":", b, ix); 1930| | serialize::op(ids_v[value.index()], ctx, b, ix); 1931| | if constexpr (N > 0) { 1932| | dump(',', b, ix); 1933| | } 1934| | } 1935| | else { 1936| | dump("\":\"", b, ix); 1937| | dump_maybe_empty(ids_v[value.index()], b, ix); 1938| | if constexpr (N == 0) { 1939| | dump('"', b, ix); 1940| | } 1941| | else { 1942| | dump("\",", b, ix); 1943| | } 1944| | } 1945| | } 1946| | if constexpr (is_memory_object) { 1947| | if (!val) [[unlikely]] { 1948| | ctx.error = error_code::invalid_variant_object; 1949| | return; 1950| | } 1951| | to>::template op()>(*val, ctx, b, ix); 1952| | } 1953| | else { 1954| | to::template op()>(val, ctx, b, ix); 1955| | } 1956| | // If we skip everything then we may have an extra comma, which we want to revert 1957| | if constexpr (Opts.skip_null_members) { 1958| | if (b[ix - 1] == ',') { 1959| | --ix; 1960| | } 1961| | } 1962| | 1963| | if constexpr (Opts.prettify) { 1964| | ctx.depth -= check_indentation_width(Opts); 1965| | if (!ensure_space(ctx, b, ix + ctx.depth + write_padding_bytes)) [[unlikely]] { 1966| | return; 1967| | } 1968| | std::memcpy(&b[ix], "\n", 1); 1969| | ++ix; 1970| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 1971| | ix += ctx.depth; 1972| | std::memcpy(&b[ix], "}", 1); 1973| | ++ix; 1974| | } 1975| | else { 1976| | dump('}', b, ix); 1977| | } 1978| | } 1979| 91| else { 1980| 91| to::template op(val, ctx, b, ix); 1981| 91| } 1982| 91| }, _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm8EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__18functionIFiiEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1087| 47| { 1088| 47| static constexpr auto name = name_v>; 1089| 47| constexpr auto n = name.size(); 1090| | 1091| 47| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1091:14): [True: 0, False: 47] ------------------ 1092| 0| return; 1093| 0| } 1094| | 1095| 47| std::memcpy(&b[ix], "\"", 1); 1096| 47| ++ix; 1097| 47| if constexpr (not name.empty()) { 1098| 47| std::memcpy(&b[ix], name.data(), n); 1099| 47| ix += n; 1100| 47| } 1101| 47| std::memcpy(&b[ix], "\"", 1); 1102| 47| ++ix; 1103| 47| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm9EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__18functionIFNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS8_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS8_RSC_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1087| 47| { 1088| 47| static constexpr auto name = name_v>; 1089| 47| constexpr auto n = name.size(); 1090| | 1091| 47| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1091:14): [True: 0, False: 47] ------------------ 1092| 0| return; 1093| 0| } 1094| | 1095| 47| std::memcpy(&b[ix], "\"", 1); 1096| 47| ++ix; 1097| 47| if constexpr (not name.empty()) { 1098| 47| std::memcpy(&b[ix], name.data(), n); 1099| 47| ix += n; 1100| 47| } 1101| 47| std::memcpy(&b[ix], "\"", 1); 1102| 47| ++ix; 1103| 47| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm10EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__18functionIFN9repe_fuzz5pointERKS4_EEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS8_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1087| 47| { 1088| 47| static constexpr auto name = name_v>; 1089| 47| constexpr auto n = name.size(); 1090| | 1091| 47| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1091:14): [True: 0, False: 47] ------------------ 1092| 0| return; 1093| 0| } 1094| | 1095| 47| std::memcpy(&b[ix], "\"", 1); 1096| 47| ++ix; 1097| 47| if constexpr (not name.empty()) { 1098| 47| std::memcpy(&b[ix], name.data(), n); 1099| 47| ix += n; 1100| 47| } 1101| 47| std::memcpy(&b[ix], "\"", 1); 1102| 47| ++ix; 1103| 47| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm11EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__18functionIFdRNS1_6vectorIdNS1_9allocatorIdEEEEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEERS9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1087| 47| { 1088| 47| static constexpr auto name = name_v>; 1089| 47| constexpr auto n = name.size(); 1090| | 1091| 47| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1091:14): [True: 0, False: 47] ------------------ 1092| 0| return; 1093| 0| } 1094| | 1095| 47| std::memcpy(&b[ix], "\"", 1); 1096| 47| ++ix; 1097| 47| if constexpr (not name.empty()) { 1098| 47| std::memcpy(&b[ix], name.data(), n); 1099| 47| ix += n; 1100| 47| } 1101| 47| std::memcpy(&b[ix], "\"", 1); 1102| 47| ++ix; 1103| 47| } _ZZN3glz2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS2_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_ENKUlTnmvE_clILm12EEEDav: 2347| 47| for_each([&]() { 2348| 47| using val_t = field_t; 2349| | 2350| | if constexpr (meta_has_skip) { 2351| | static constexpr meta_context mctx{.op = operation::serialize}; 2352| | if constexpr (meta::skip(reflect::keys[I], mctx)) return; 2353| | } 2354| | if constexpr (meta_has_skip_if) { 2355| | static constexpr auto key = glz::get(reflect::keys); 2356| | static constexpr meta_context mctx{.op = operation::serialize}; 2357| | decltype(auto) field_value = [&]() -> decltype(auto) { 2358| | if constexpr (reflectable) { 2359| | return get(t); 2360| | } 2361| | else { 2362| | return get_member(value, glz::get(reflect::values)); 2363| | } 2364| | }(); 2365| | if (meta::skip_if(field_value, key, mctx)) return; 2366| | } 2367| | 2368| 47| constexpr bool write_function_pointers = check_write_function_pointers(Opts); 2369| | if constexpr (always_skipped || (!write_function_pointers && is_any_function_ptr)) { 2370| | return; 2371| | } 2372| 47| else { 2373| | if constexpr (null_t && Opts.skip_null_members) { 2374| | if constexpr (always_null_t) 2375| | return; 2376| | else { 2377| | const auto is_null = [&]() { 2378| | decltype(auto) element = [&]() -> decltype(auto) { 2379| | if constexpr (reflectable) { 2380| | return get(t); 2381| | } 2382| | else { 2383| | return get(reflect::values); 2384| | } 2385| | }; 2386| | 2387| | if constexpr (nullable_wrapper) { 2388| | return !bool(element()(value).val); 2389| | } 2390| | else if constexpr (nullable_value_t) { 2391| | return !get_member(value, element()).has_value(); 2392| | } 2393| | else { 2394| | return !bool(get_member(value, element())); 2395| | } 2396| | }(); 2397| | if (is_null) return; 2398| | } 2399| | } 2400| | else if constexpr (is_specialization_v && Opts.skip_null_members && 2401| | custom_getter_returns_nullable()) { 2402| | if (is_custom_field_null(value, t, ctx)) return; 2403| | } 2404| 47| else if constexpr (Opts.skip_null_members && glaze_value_is_nullable()) { 2405| 47| if (is_glaze_value_field_null(value, t)) return; 2406| 47| } 2407| | 2408| | if constexpr (check_skip_default_members(Opts) && has_skippable_default) { 2409| | decltype(auto) member = [&]() -> decltype(auto) { 2410| | if constexpr (reflectable) { 2411| | return get_member(value, get(t)); 2412| | } 2413| | else { 2414| | return get_member(value, get(reflect::values)); 2415| | } 2416| | }(); 2417| | if (is_default_value(member)) return; 2418| | } 2419| | 2420| | if constexpr (Opts.prettify) { 2421| | if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] { 2422| | return; 2423| | } 2424| | } 2425| 47| else { 2426| 47| if (!ensure_space(ctx, b, ix + padding)) [[unlikely]] { ------------------ | Branch (2426:29): [True: 0, False: 47] ------------------ 2427| 0| return; 2428| 0| } 2429| 47| } 2430| | 2431| 47| if (first) { ------------------ | Branch (2431:26): [True: 0, False: 47] ------------------ 2432| 0| first = false; 2433| 0| } 2434| 47| else { 2435| | // Null members may be skipped so we can't just write it out for all but the last member 2436| | if constexpr (Opts.prettify) { 2437| | std::memcpy(&b[ix], ",\n", 2); 2438| | ix += 2; 2439| | std::memset(&b[ix], check_indentation_char(Opts), ctx.depth); 2440| | ix += ctx.depth; 2441| | } 2442| 47| else { 2443| 47| std::memcpy(&b[ix], ",", 1); 2444| 47| ++ix; 2445| 47| } 2446| | if constexpr (is_output_streaming) { 2447| | flush_buffer(b, ix); 2448| | } 2449| 47| } 2450| | 2451| | // MSVC requires get rather than keys[I] 2452| 47| static constexpr auto key = glz::get(reflect::keys); // GCC 14 requires auto here 2453| 47| static constexpr auto quoted_key = quoted_key_v; 2454| 47| static constexpr auto n = quoted_key.size(); 2455| 47| std::memcpy(&b[ix], quoted_key.data(), n); 2456| 47| ix += n; 2457| | 2458| 47| static constexpr auto check_opts = required_padding() ? write_unchecked_on() : Opts; ------------------ | Branch (2458:57): [Folded, False: 47] ------------------ 2459| 47| if constexpr (reflectable) { 2460| 47| to::template op(get_member(value, get(t)), ctx, b, ix); 2461| | } 2462| | else { 2463| | to::template op(get_member(value, get(reflect::values)), ctx, b, 2464| | ix); 2465| | } 2466| 47| } 2467| 47| }); _ZN3glz2toILj10ENSt3__18functionIFvvEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS4_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 1087| 47| { 1088| 47| static constexpr auto name = name_v>; 1089| 47| constexpr auto n = name.size(); 1090| | 1091| 47| if (!ensure_space(ctx, b, ix + 8 + n)) [[unlikely]] { ------------------ | Branch (1091:14): [True: 0, False: 47] ------------------ 1092| 0| return; 1093| 0| } 1094| | 1095| 47| std::memcpy(&b[ix], "\"", 1); 1096| 47| ++ix; 1097| 47| if constexpr (not name.empty()) { 1098| 47| std::memcpy(&b[ix], name.data(), n); 1099| 47| ix += n; 1100| 47| } 1101| 47| std::memcpy(&b[ix], "\"", 1); 1102| 47| ++ix; 1103| 47| } _ZN3glz2toILj10EdE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERdTkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_: 737| 444| { 738| 444| if constexpr (not check_write_unchecked(Opts)) { 739| 444| static_assert(required_padding()); 740| 444| if (!ensure_space(ctx, b, ix + required_padding())) [[unlikely]] { ------------------ | Branch (740:17): [True: 0, False: 444] ------------------ 741| 0| return; 742| 0| } 743| 444| } 744| | 745| 444| static constexpr auto O = write_unchecked_on(); 746| | 747| | if constexpr (check_quoted_num(Opts)) { 748| | std::memcpy(&b[ix], "\"", 1); 749| | ++ix; 750| | write_chars::op(value, ctx, b, ix); 751| | std::memcpy(&b[ix], "\"", 1); 752| | ++ix; 753| | } 754| 444| else { 755| 444| write_chars::op(value, ctx, b, ix); 756| 444| } 757| 444| } _ZN3glz16required_paddingIdEEmv: 461| 444| { 462| 444| constexpr auto value = []() -> size_t { 463| 444| if constexpr (boolean_like) { 464| 444| return 8; 465| 444| } 466| 444| else if constexpr (num_t) { 467| 444| if constexpr (std::floating_point) { 468| 444| if constexpr (sizeof(T) > 8) { 469| 444| return 64; 470| 444| } 471| 444| else if constexpr (sizeof(T) > 4) { 472| | // zmij scratch + 4 for optional quotes and trailing comma. 473| 444| return zmij::double_buffer_size + 4; 474| 444| } 475| 444| else { 476| 444| return zmij::float_buffer_size + 4; 477| 444| } 478| 444| } 479| 444| else if constexpr (sizeof(T) > 4) { 480| 444| return 24; 481| 444| } 482| 444| else if constexpr (sizeof(T) > 2) { 483| 444| return 16; 484| 444| } 485| 444| else { 486| 444| return 8; 487| 444| } 488| 444| } 489| 444| else if constexpr (nullable_like) { 490| 444| if constexpr (has_value_type) { 491| 444| return required_padding(); 492| 444| } 493| 444| else if constexpr (has_element_type) { 494| 444| return required_padding(); 495| 444| } 496| 444| else { 497| 444| return 0; 498| 444| } 499| 444| } 500| 444| else if constexpr (always_null_t) { 501| 444| return 8; 502| 444| } 503| 444| else { 504| 444| return 0; 505| 444| } 506| 444| }(); 507| | 508| | if constexpr (value >= (write_padding_bytes - 16)) { 509| | // we always require 16 bytes available from write_padding_bytes 510| | // for opening and closing characters 511| | return 0; 512| | } 513| 444| return value; 514| 444| } _ZN3glz2toILj10ENSt3__18optionalIdEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_TkNS_10is_contextERNS_7contextERNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEEvOT0_OT1_OT2_RT3_: 1613| 44| { 1614| 44| if (value) { ------------------ | Branch (1614:14): [True: 0, False: 44] ------------------ 1615| 0| if constexpr (required_padding()) { 1616| 0| serialize::op(*value, ctx, b, ix); 1617| | } 1618| | else { 1619| | serialize::op()>(*value, ctx, b, ix); 1620| | } 1621| 0| } 1622| 44| else { 1623| 44| dump("null", b, ix); 1624| 44| } 1625| 44| } _ZN3glz6to_tieIRN9repe_fuzz5pointELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 362k| { 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| 362k| else if constexpr (N == 2) { 146| 362k| auto& [p0, p1] = t; 147| 362k| 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| 362k| } _ZN3glz6to_tieIRN9repe_fuzz6nestedELm2EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 326k| { 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| 326k| else if constexpr (N == 2) { 146| 326k| auto& [p0, p1] = t; 147| 326k| 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| 326k| } _ZN3glz6to_tieIRN9repe_fuzz8fuzz_apiELm13EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 380k| { 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| 380k| else if constexpr (N == 13) { 190| 380k| auto& [p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12] = t; 191| 380k| 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| 380k| } _ZN3glz6to_tieIRN9repe_fuzz6amountELm1EQleT0_L_ZNS_6detail25max_pure_reflection_countEEEEDcOT_: 137| 19.5k| { 138| | if constexpr (N == 0) { 139| | return tuple{}; 140| | } 141| 19.5k| else if constexpr (N == 1) { 142| 19.5k| auto& [p] = t; 143| 19.5k| 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| 19.5k| } repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE2onIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 295| 304k| { 296| 304k| using impl = registry_impl; 297| | 298| 304k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 299| 304k| impl::register_endpoint(root, value, *this); 300| 304k| } 301| | 302| 304k| register_members(value); 303| 304k| } repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 164| 304k| { 165| 304k| using namespace glz::detail; 166| 304k| static constexpr auto N = reflect::size; 167| | 168| 304k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 304k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 304k| return to_tie(value); 171| 304k| } 172| 304k| else { 173| 304k| return nullptr; 174| 304k| } 175| 304k| }(); 176| | 177| 304k| using impl = registry_impl; 178| | 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| 304k| if constexpr (std::is_invocable_v) { 203| 304k| using Result = std::decay_t>; 204| 304k| impl::template register_function_endpoint(full_key, func, *this); 205| 304k| } 206| 304k| else if constexpr (is_invocable_concrete>) { 207| 304k| using Tuple = invocable_args_t>; 208| 304k| constexpr auto N = glz::tuple_size_v; 209| 304k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 304k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 304k| impl::template register_param_function_endpoint(full_key, func, *this); 214| 304k| } 215| 304k| else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| 304k| using Tuple = function_ptr_args_t>; 218| 304k| constexpr auto N = glz::tuple_size_v; 219| 304k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| 304k| using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| 304k| impl::template register_param_function_endpoint(full_key, func, *this); 224| 304k| } 225| 304k| else if constexpr (std::is_pointer_v> && 226| 304k| (glaze_object_t>> || 227| 304k| reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| 304k| if (func) { // Only traverse if pointer is valid 230| 304k| on>, full_key>(*func); 231| 304k| impl::template register_object_endpoint>>( 232| 304k| full_key, *func, *this); 233| 304k| } 234| | // else: skip registration for null pointers - no endpoints created 235| 304k| } 236| 304k| else if constexpr (glaze_object_t> || reflectable>) { 237| 304k| on, full_key>(func); 238| | 239| 304k| impl::template register_object_endpoint>(full_key, func, *this); 240| 304k| } 241| 304k| else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| 304k| impl::template register_value_endpoint>(full_key, func, *this); 244| 304k| } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| 304k| if constexpr (std::is_member_function_pointer_v>) { 249| 304k| using F = std::decay_t; 250| 304k| using Ret = typename return_type::type; 251| 304k| using Tuple = typename inputs_as_tuple::type; 252| 304k| constexpr auto n_args = glz::tuple_size_v; 253| 304k| if constexpr (std::is_void_v) { 254| 304k| if constexpr (n_args == 0) { 255| 304k| impl::template register_member_function_endpoint(full_key, value, func, *this); 256| 304k| } 257| 304k| else if constexpr (n_args == 1) { 258| 304k| using Input = std::decay_t>; 259| 304k| impl::template register_member_function_with_params_endpoint(full_key, value, 260| 304k| func, *this); 261| 304k| } 262| 304k| else { 263| 304k| static_assert(false_v, "function cannot have more than one input"); 264| 304k| } 265| 304k| } 266| 304k| else { 267| | // Member function pointers 268| 304k| if constexpr (n_args == 0) { 269| 304k| impl::template register_member_function_endpoint(full_key, value, func, *this); 270| 304k| } 271| 304k| else if constexpr (n_args == 1) { 272| 304k| using Input = std::decay_t>; 273| 304k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 304k| func, *this); 275| 304k| } 276| 304k| else { 277| 304k| static_assert(false_v, "function cannot have more than one input"); 278| 304k| } 279| 304k| } 280| 304k| } 281| 304k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 304k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 304k| } 286| 304k| } 287| 304k| }); 288| 304k| } repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 168| 304k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| | if constexpr (reflectable && requires { to_tie(value); }) { 170| | return to_tie(value); 171| | } 172| 304k| else { 173| 304k| return nullptr; 174| 304k| } 175| 304k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDav: 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 304k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 304k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 304k| } 286| 304k| } 287| 304k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDavENKUlvE_clEv: 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| | if constexpr (reflectable) { 182| | return get_member(value, get(t)); 183| | } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDav: 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| 304k| if constexpr (std::is_member_function_pointer_v>) { 249| 304k| using F = std::decay_t; 250| 304k| using Ret = typename return_type::type; 251| 304k| using Tuple = typename inputs_as_tuple::type; 252| 304k| constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| 304k| else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| 304k| else if constexpr (n_args == 1) { 272| 304k| using Input = std::decay_t>; 273| 304k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 304k| func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| 304k| } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| 304k| } 287| 304k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDavENKUlvE_clEv: 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| | if constexpr (reflectable) { 182| | return get_member(value, get(t)); 183| | } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDav: 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| 304k| if constexpr (std::is_member_function_pointer_v>) { 249| 304k| using F = std::decay_t; 250| 304k| using Ret = typename return_type::type; 251| 304k| using Tuple = typename inputs_as_tuple::type; 252| 304k| constexpr auto n_args = glz::tuple_size_v; 253| 304k| if constexpr (std::is_void_v) { 254| 304k| if constexpr (n_args == 0) { 255| 304k| impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| 304k| } 287| 304k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDavENKUlvE_clEv: 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| | if constexpr (reflectable) { 182| | return get_member(value, get(t)); 183| | } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDav: 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| 304k| if constexpr (std::is_member_function_pointer_v>) { 249| 304k| using F = std::decay_t; 250| 304k| using Ret = typename return_type::type; 251| 304k| using Tuple = typename inputs_as_tuple::type; 252| 304k| constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| 304k| else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| 304k| else if constexpr (n_args == 1) { 272| 304k| using Input = std::decay_t>; 273| 304k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 304k| func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| 304k| } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| 304k| } 287| 304k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDavENKUlvE_clEv: 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| | if constexpr (reflectable) { 182| | return get_member(value, get(t)); 183| | } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDav: 179| 304k| for_each([&]() { 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| 304k| if constexpr (reflectable) { 182| 304k| return get_member(value, get(t)); 183| 304k| } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); 188| | 189| 304k| static constexpr auto key = reflect::keys[I]; 190| | 191| 304k| static constexpr std::string_view full_key = [&] { 192| 304k| if constexpr (parent == detail::empty_path) { 193| 304k| return join_v, key>; 194| 304k| } 195| 304k| else { 196| 304k| return join_v, key>; 197| 304k| } 198| 304k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 304k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 304k| else { 246| 304k| static_assert(std::is_lvalue_reference_v); 247| | 248| 304k| if constexpr (std::is_member_function_pointer_v>) { 249| 304k| using F = std::decay_t; 250| 304k| using Ret = typename return_type::type; 251| 304k| using Tuple = typename inputs_as_tuple::type; 252| 304k| constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| 304k| else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| 304k| else if constexpr (n_args == 1) { 272| 304k| using Input = std::decay_t>; 273| 304k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 304k| func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| 304k| } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| 304k| } 287| 304k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDavENKUlvE_clEv: 180| 304k| decltype(auto) func = [&]() -> decltype(auto) { 181| | if constexpr (reflectable) { 182| | return get_member(value, get(t)); 183| | } 184| 304k| else { 185| 304k| return get_member(value, get(reflect::values)); 186| 304k| } 187| 304k| }(); repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE2onIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 295| 318k| { 296| 318k| using impl = registry_impl; 297| | 298| 318k| if constexpr (parent == root && (glaze_object_t || reflectable)) { 299| 318k| impl::register_endpoint(root, value, *this); 300| 318k| } 301| | 302| 318k| register_members(value); 303| 318k| } repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_: 164| 318k| { 165| 318k| using namespace glz::detail; 166| 318k| static constexpr auto N = reflect::size; 167| | 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| 318k| } 172| 318k| else { 173| 318k| return nullptr; 174| 318k| } 175| 318k| }(); 176| | 177| 318k| using impl = registry_impl; 178| | 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| 318k| if constexpr (std::is_invocable_v) { 203| 318k| using Result = std::decay_t>; 204| 318k| impl::template register_function_endpoint(full_key, func, *this); 205| 318k| } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| 318k| } 215| 318k| else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| 318k| using Tuple = function_ptr_args_t>; 218| 318k| constexpr auto N = glz::tuple_size_v; 219| 318k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| 318k| using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 224| 318k| } 225| 318k| else if constexpr (std::is_pointer_v> && 226| 318k| (glaze_object_t>> || 227| 318k| reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| 318k| if (func) { // Only traverse if pointer is valid 230| 318k| on>, full_key>(*func); 231| 318k| impl::template register_object_endpoint>>( 232| 318k| full_key, *func, *this); 233| 318k| } 234| | // else: skip registration for null pointers - no endpoints created 235| 318k| } 236| 318k| else if constexpr (glaze_object_t> || reflectable>) { 237| 318k| on, full_key>(func); 238| | 239| 318k| impl::template register_object_endpoint>(full_key, func, *this); 240| 318k| } 241| 318k| else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| 318k| impl::template register_value_endpoint>(full_key, func, *this); 244| 318k| } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| 318k| if constexpr (std::is_member_function_pointer_v>) { 249| 318k| using F = std::decay_t; 250| 318k| using Ret = typename return_type::type; 251| 318k| using Tuple = typename inputs_as_tuple::type; 252| 318k| constexpr auto n_args = glz::tuple_size_v; 253| 318k| if constexpr (std::is_void_v) { 254| 318k| if constexpr (n_args == 0) { 255| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 256| 318k| } 257| 318k| else if constexpr (n_args == 1) { 258| 318k| using Input = std::decay_t>; 259| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 260| 318k| func, *this); 261| 318k| } 262| 318k| else { 263| 318k| static_assert(false_v, "function cannot have more than one input"); 264| 318k| } 265| 318k| } 266| 318k| else { 267| | // Member function pointers 268| 318k| if constexpr (n_args == 0) { 269| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 270| 318k| } 271| 318k| else if constexpr (n_args == 1) { 272| 318k| using Input = std::decay_t>; 273| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 318k| func, *this); 275| 318k| } 276| 318k| else { 277| 318k| static_assert(false_v, "function cannot have more than one input"); 278| 318k| } 279| 318k| } 280| 318k| } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); 288| 318k| } repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlvE_clEv: 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| | } 172| | else { 173| | return nullptr; 174| | } 175| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm0EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm1EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| 318k| else if constexpr (glaze_object_t> || reflectable>) { 237| 318k| on, full_key>(func); 238| | 239| 318k| impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm2EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE2onIL_ZNS_6detailL10empty_pathEEN9repe_fuzz5pointEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_: 295| 318k| { 296| 318k| using impl = registry_impl; 297| | 298| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 299| | impl::register_endpoint(root, value, *this); 300| | } 301| | 302| 318k| register_members(value); 303| 318k| } repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz5pointEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_: 164| 318k| { 165| 318k| using namespace glz::detail; 166| 318k| static constexpr auto N = reflect::size; 167| | 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| 318k| } 172| 318k| else { 173| 318k| return nullptr; 174| 318k| } 175| 318k| }(); 176| | 177| 318k| using impl = registry_impl; 178| | 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| 318k| if constexpr (std::is_invocable_v) { 203| 318k| using Result = std::decay_t>; 204| 318k| impl::template register_function_endpoint(full_key, func, *this); 205| 318k| } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| 318k| } 215| 318k| else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| 318k| using Tuple = function_ptr_args_t>; 218| 318k| constexpr auto N = glz::tuple_size_v; 219| 318k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| 318k| using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 224| 318k| } 225| 318k| else if constexpr (std::is_pointer_v> && 226| 318k| (glaze_object_t>> || 227| 318k| reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| 318k| if (func) { // Only traverse if pointer is valid 230| 318k| on>, full_key>(*func); 231| 318k| impl::template register_object_endpoint>>( 232| 318k| full_key, *func, *this); 233| 318k| } 234| | // else: skip registration for null pointers - no endpoints created 235| 318k| } 236| 318k| else if constexpr (glaze_object_t> || reflectable>) { 237| 318k| on, full_key>(func); 238| | 239| 318k| impl::template register_object_endpoint>(full_key, func, *this); 240| 318k| } 241| 318k| else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| 318k| impl::template register_value_endpoint>(full_key, func, *this); 244| 318k| } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| 318k| if constexpr (std::is_member_function_pointer_v>) { 249| 318k| using F = std::decay_t; 250| 318k| using Ret = typename return_type::type; 251| 318k| using Tuple = typename inputs_as_tuple::type; 252| 318k| constexpr auto n_args = glz::tuple_size_v; 253| 318k| if constexpr (std::is_void_v) { 254| 318k| if constexpr (n_args == 0) { 255| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 256| 318k| } 257| 318k| else if constexpr (n_args == 1) { 258| 318k| using Input = std::decay_t>; 259| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 260| 318k| func, *this); 261| 318k| } 262| 318k| else { 263| 318k| static_assert(false_v, "function cannot have more than one input"); 264| 318k| } 265| 318k| } 266| 318k| else { 267| | // Member function pointers 268| 318k| if constexpr (n_args == 0) { 269| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 270| 318k| } 271| 318k| else if constexpr (n_args == 1) { 272| 318k| using Input = std::decay_t>; 273| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 318k| func, *this); 275| 318k| } 276| 318k| else { 277| 318k| static_assert(false_v, "function cannot have more than one input"); 278| 318k| } 279| 318k| } 280| 318k| } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); 288| 318k| } repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| | } 172| | else { 173| | return nullptr; 174| | } 175| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| 318k| else if constexpr (glaze_object_t> || reflectable>) { 237| 318k| on, full_key>(func); 238| | 239| 318k| impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm3EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE2onIL_ZNS_6detailL10empty_pathEEN9repe_fuzz6nestedEL_ZZZNS2_16register_membersIL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_: 295| 318k| { 296| 318k| using impl = registry_impl; 297| | 298| | if constexpr (parent == root && (glaze_object_t || reflectable)) { 299| | impl::register_endpoint(root, value, *this); 300| | } 301| | 302| 318k| register_members(value); 303| 318k| } repe_registry.cpp:_ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz6nestedEL_ZZZNS3_IL_ZNS4_L10empty_pathEENS5_8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS8_E11reflectableIS8_EEEvSA_: 164| 318k| { 165| 318k| using namespace glz::detail; 166| 318k| static constexpr auto N = reflect::size; 167| | 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| 318k| } 172| 318k| else { 173| 318k| return nullptr; 174| 318k| } 175| 318k| }(); 176| | 177| 318k| using impl = registry_impl; 178| | 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| 318k| if constexpr (std::is_invocable_v) { 203| 318k| using Result = std::decay_t>; 204| 318k| impl::template register_function_endpoint(full_key, func, *this); 205| 318k| } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| 318k| } 215| 318k| else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| 318k| using Tuple = function_ptr_args_t>; 218| 318k| constexpr auto N = glz::tuple_size_v; 219| 318k| static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| 318k| using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 224| 318k| } 225| 318k| else if constexpr (std::is_pointer_v> && 226| 318k| (glaze_object_t>> || 227| 318k| reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| 318k| if (func) { // Only traverse if pointer is valid 230| 318k| on>, full_key>(*func); 231| 318k| impl::template register_object_endpoint>>( 232| 318k| full_key, *func, *this); 233| 318k| } 234| | // else: skip registration for null pointers - no endpoints created 235| 318k| } 236| 318k| else if constexpr (glaze_object_t> || reflectable>) { 237| 318k| on, full_key>(func); 238| | 239| 318k| impl::template register_object_endpoint>(full_key, func, *this); 240| 318k| } 241| 318k| else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| 318k| impl::template register_value_endpoint>(full_key, func, *this); 244| 318k| } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| 318k| if constexpr (std::is_member_function_pointer_v>) { 249| 318k| using F = std::decay_t; 250| 318k| using Ret = typename return_type::type; 251| 318k| using Tuple = typename inputs_as_tuple::type; 252| 318k| constexpr auto n_args = glz::tuple_size_v; 253| 318k| if constexpr (std::is_void_v) { 254| 318k| if constexpr (n_args == 0) { 255| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 256| 318k| } 257| 318k| else if constexpr (n_args == 1) { 258| 318k| using Input = std::decay_t>; 259| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 260| 318k| func, *this); 261| 318k| } 262| 318k| else { 263| 318k| static_assert(false_v, "function cannot have more than one input"); 264| 318k| } 265| 318k| } 266| 318k| else { 267| | // Member function pointers 268| 318k| if constexpr (n_args == 0) { 269| 318k| impl::template register_member_function_endpoint(full_key, value, func, *this); 270| 318k| } 271| 318k| else if constexpr (n_args == 1) { 272| 318k| using Input = std::decay_t>; 273| 318k| impl::template register_member_function_with_params_endpoint(full_key, value, 274| 318k| func, *this); 275| 318k| } 276| 318k| else { 277| 318k| static_assert(false_v, "function cannot have more than one input"); 278| 318k| } 279| 318k| } 280| 318k| } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); 288| 318k| } repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 168| 318k| [[maybe_unused]] decltype(auto) t = [&]() -> decltype(auto) { 169| 318k| if constexpr (reflectable && requires { to_tie(value); }) { 170| 318k| return to_tie(value); 171| | } 172| | else { 173| | return nullptr; 174| | } 175| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_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: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm4EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm5EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm6EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| 318k| else { 246| 318k| static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| 318k| else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| 318k| impl::template register_variable_endpoint>(full_key, func, *this); 285| 318k| } 286| 318k| } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm7EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm8EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm9EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm10EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| | if constexpr (std::is_invocable_v) { 203| | using Result = std::decay_t>; 204| | impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| 318k| else if constexpr (is_invocable_concrete>) { 207| 318k| using Tuple = invocable_args_t>; 208| 318k| constexpr auto N = glz::tuple_size_v; 209| 318k| static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| 318k| using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| 318k| impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm11EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); repe_registry.cpp:_ZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDav: 179| 318k| for_each([&]() { 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| 318k| } 184| 318k| else { 185| 318k| return get_member(value, get(reflect::values)); 186| 318k| } 187| 318k| }(); 188| | 189| 318k| static constexpr auto key = reflect::keys[I]; 190| | 191| 318k| static constexpr std::string_view full_key = [&] { 192| 318k| if constexpr (parent == detail::empty_path) { 193| 318k| return join_v, key>; 194| 318k| } 195| 318k| else { 196| 318k| return join_v, key>; 197| 318k| } 198| 318k| }(); 199| | 200| | // This logic chain should match glz::cli_menu 201| 318k| using Func = decltype(func); 202| 318k| if constexpr (std::is_invocable_v) { 203| 318k| using Result = std::decay_t>; 204| 318k| impl::template register_function_endpoint(full_key, func, *this); 205| | } 206| | else if constexpr (is_invocable_concrete>) { 207| | using Tuple = invocable_args_t>; 208| | constexpr auto N = glz::tuple_size_v; 209| | static_assert(N == 1, "Only one input is allowed for your function"); 210| | 211| | using Params = glz::tuple_element_t<0, Tuple>; 212| | 213| | impl::template register_param_function_endpoint(full_key, func, *this); 214| | } 215| | else if constexpr (is_function_ptr_invocable>) { 216| | // Handle function pointers with arguments (e.g., void(*)(int)) 217| | using Tuple = function_ptr_args_t>; 218| | constexpr auto N = glz::tuple_size_v; 219| | static_assert(N == 1, "Only one input is allowed for your function pointer"); 220| | 221| | using Params = glz::tuple_element_t<0, Tuple>; 222| | 223| | impl::template register_param_function_endpoint(full_key, func, *this); 224| | } 225| | else if constexpr (std::is_pointer_v> && 226| | (glaze_object_t>> || 227| | reflectable>>)) { 228| | // Handle pointer members explicitly for RPC traversal 229| | if (func) { // Only traverse if pointer is valid 230| | on>, full_key>(*func); 231| | impl::template register_object_endpoint>>( 232| | full_key, *func, *this); 233| | } 234| | // else: skip registration for null pointers - no endpoints created 235| | } 236| | else if constexpr (glaze_object_t> || reflectable>) { 237| | on, full_key>(func); 238| | 239| | impl::template register_object_endpoint>(full_key, func, *this); 240| | } 241| | else if constexpr (not std::is_lvalue_reference_v) { 242| | // For glz::custom, glz::manage, etc. 243| | impl::template register_value_endpoint>(full_key, func, *this); 244| | } 245| | else { 246| | static_assert(std::is_lvalue_reference_v); 247| | 248| | if constexpr (std::is_member_function_pointer_v>) { 249| | using F = std::decay_t; 250| | using Ret = typename return_type::type; 251| | using Tuple = typename inputs_as_tuple::type; 252| | constexpr auto n_args = glz::tuple_size_v; 253| | if constexpr (std::is_void_v) { 254| | if constexpr (n_args == 0) { 255| | impl::template register_member_function_endpoint(full_key, value, func, *this); 256| | } 257| | else if constexpr (n_args == 1) { 258| | using Input = std::decay_t>; 259| | impl::template register_member_function_with_params_endpoint(full_key, value, 260| | func, *this); 261| | } 262| | else { 263| | static_assert(false_v, "function cannot have more than one input"); 264| | } 265| | } 266| | else { 267| | // Member function pointers 268| | if constexpr (n_args == 0) { 269| | impl::template register_member_function_endpoint(full_key, value, func, *this); 270| | } 271| | else if constexpr (n_args == 1) { 272| | using Input = std::decay_t>; 273| | impl::template register_member_function_with_params_endpoint(full_key, value, 274| | func, *this); 275| | } 276| | else { 277| | static_assert(false_v, "function cannot have more than one input"); 278| | } 279| | } 280| | } 281| | else { 282| | // this is a variable and not a function, so we build RPC read/write calls 283| | // We can't remove const here, because const fields need to be able to be written 284| | impl::template register_variable_endpoint>(full_key, func, *this); 285| | } 286| | } 287| 318k| }); repe_registry.cpp:_ZZZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS4_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS7_EEEvRT0_ENKUlTnDavE_clILm12EEEDavENKUlvE_clEv: 180| 318k| decltype(auto) func = [&]() -> decltype(auto) { 181| 318k| if constexpr (reflectable) { 182| 318k| return get_member(value, get(t)); 183| | } 184| | else { 185| | return get_member(value, get(reflect::values)); 186| | } 187| 318k| }(); _ZN3glz8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE4callENSt3__14spanIKcLm18446744073709551615EEERNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEQeqT0_L_ZNS_4REPEEE: 405| 318k| { 406| 318k| response_buffer.clear(); // Empty buffer means no response 407| 318k| repe::response_builder resp{response_buffer}; 408| | 409| | // Parse request with zero-copy (header copied to stack, query/body are views) 410| 318k| auto result = repe::parse_request(request); 411| 318k| if (!result) { ------------------ | Branch (411:14): [True: 26.3k, False: 291k] ------------------ 412| | // Use the specific error code from parse_result 413| | // Note: parse_request copies the header before validation, so we can access it 414| 26.3k| resp.reset(result.request.hdr.id); 415| | 416| | // Build appropriate error message based on error code 417| 26.3k| if (result.ec == error_code::version_mismatch) { ------------------ | Branch (417:17): [True: 26, False: 26.3k] ------------------ 418| 26| resp.set_error(result.ec, detail::build_version_error(result.request.hdr.version)); 419| 26| } 420| 26.3k| else if (result.ec == error_code::invalid_header) { ------------------ | Branch (420:22): [True: 26.2k, False: 64] ------------------ 421| | // Could be magic mismatch, length mismatch, or buffer too small 422| 26.2k| if (request.size() >= sizeof(repe::header)) { ------------------ | Branch (422:20): [True: 8.57k, False: 17.7k] ------------------ 423| 8.57k| const auto& hdr = result.request.hdr; 424| 8.57k| if (hdr.spec != repe::repe_magic) { ------------------ | Branch (424:23): [True: 7.83k, False: 744] ------------------ 425| 7.83k| resp.set_error(result.ec, detail::build_magic_error(hdr.spec)); 426| 7.83k| } 427| 744| else { 428| | // Length mismatch, or query/body lengths that overflow the total 429| | // (overflow-safe: query_length/body_length are attacker-controlled). 430| 744| uint64_t expected{}; 431| 744| if (repe::checked_message_length(hdr, expected)) { ------------------ | Branch (431:26): [True: 584, False: 160] ------------------ 432| 584| resp.set_error(result.ec, detail::build_length_error(expected, hdr.length)); 433| 584| } 434| 160| else { 435| 160| resp.set_error(result.ec, 436| 160| detail::build_length_overflow_error(hdr.query_length, hdr.body_length)); 437| 160| } 438| 744| } 439| 8.57k| } 440| 17.7k| else { 441| 17.7k| resp.set_error(result.ec, "Invalid header"); 442| 17.7k| } 443| 26.2k| } 444| 64| else { 445| 64| resp.set_error(result.ec, "Failed to parse request"); 446| 64| } 447| 26.3k| return; 448| 26.3k| } 449| | 450| 291k| const auto& req = result.request; 451| | 452| | // Look up endpoint (transparent comparison avoids allocation) 453| 291k| auto it = endpoints.find(req.query); 454| 291k| if (it == endpoints.end()) { ------------------ | Branch (454:14): [True: 3.51k, False: 288k] ------------------ 455| 3.51k| if (req.is_notify()) { ------------------ | Branch (455:17): [True: 1.42k, False: 2.09k] ------------------ 456| 1.42k| return; // Silent ignore for unknown notifications (buffer stays empty) 457| 1.42k| } 458| 2.09k| resp.reset(req); 459| 2.09k| resp.set_error(error_code::method_not_found, detail::build_invalid_query_error(req.query)); 460| 2.09k| return; 461| 3.51k| } 462| | 463| | // If request has an error, just echo it back -- unless it is a notification, whose sender 464| | // has said it will not read a reply, so answering one desynchronizes the connection: the 465| | // client takes the echo as the answer to its next call. The header parsed and validated 466| | // cleanly to reach here, so its notify bit can be trusted, which is what separates this 467| | // from the malformed-header paths above. 468| 288k| if (bool(req.hdr.ec)) { ------------------ | Branch (468:14): [True: 2.97k, False: 285k] ------------------ 469| 2.97k| if (req.is_notify()) { ------------------ | Branch (469:17): [True: 2.37k, False: 599] ------------------ 470| 2.37k| return; // Silent ignore for a notification that carries an error (buffer stays empty) 471| 2.37k| } 472| 599| resp.reset(req); 473| 599| resp.set_error(req.hdr.ec); 474| 599| return; 475| 2.97k| } 476| | 477| | // Zero-copy call: state_view references the parsed request and response builder directly 478| 285k| repe::state_view state{req, resp}; 479| | 480| 285k| try { 481| 285k| it->second(state); 482| 285k| } 483| 285k| catch (const std::exception& e) { 484| 0| resp.reset(req); 485| 0| resp.set_error(error_code::parse_error, detail::build_registry_error(req.query, e.what())); 486| 0| return; 487| 0| } 488| 285k| catch (...) { 489| 0| resp.reset(req); 490| 0| resp.set_error(error_code::parse_error, "Unknown error"); 491| 0| return; 492| 0| } 493| | 494| | // For notifications, response buffer stays empty (no response sent) 495| 285k| } _ZN3glz6detail19build_version_errorEh: 43| 26| { 44| 26| auto& buf = error_buffer(); 45| 26| buf = "REPE version mismatch: expected 1, got "; 46| 26| const auto n = buf.size(); 47| 26| buf.resize(n + 8); 48| 26| auto* end = glz::to_chars(buf.data() + n, uint32_t(version)); 49| 26| buf.resize(size_t(end - buf.data())); 50| 26| return buf; 51| 26| } _ZN3glz6detail12error_bufferEv: 18| 10.6k| { 19| 10.6k| thread_local std::string buffer; 20| 10.6k| buffer.clear(); 21| 10.6k| return buffer; 22| 10.6k| } _ZN3glz6detail17build_magic_errorEt: 89| 7.83k| { 90| 7.83k| auto& buf = error_buffer(); 91| 7.83k| buf = "REPE magic number mismatch: expected 0x1507, got 0x"; 92| 7.83k| constexpr char hex_chars[] = "0123456789abcdef"; 93| 7.83k| char hex[4]; 94| 7.83k| hex[0] = hex_chars[(spec >> 12) & 0xF]; 95| 7.83k| hex[1] = hex_chars[(spec >> 8) & 0xF]; 96| 7.83k| hex[2] = hex_chars[(spec >> 4) & 0xF]; 97| 7.83k| hex[3] = hex_chars[spec & 0xF]; 98| 7.83k| buf.append(hex, 4); 99| 7.83k| return buf; 100| 7.83k| } _ZN3glz6detail18build_length_errorEmm: 54| 584| { 55| 584| auto& buf = error_buffer(); 56| 584| buf = "REPE length mismatch: expected "; 57| 584| auto n = buf.size(); 58| 584| buf.resize(n + 24); 59| 584| auto* end = glz::to_chars(buf.data() + n, expected); 60| 584| buf.resize(size_t(end - buf.data())); 61| 584| buf.append(", got "); 62| 584| n = buf.size(); 63| 584| buf.resize(n + 24); 64| 584| end = glz::to_chars(buf.data() + n, actual); 65| 584| buf.resize(size_t(end - buf.data())); 66| 584| return buf; 67| 584| } _ZN3glz6detail27build_length_overflow_errorEmm: 72| 160| { 73| 160| auto& buf = error_buffer(); 74| 160| buf = "REPE length overflow: query_length "; 75| 160| auto n = buf.size(); 76| 160| buf.resize(n + 24); 77| 160| auto* end = glz::to_chars(buf.data() + n, query_length); 78| 160| buf.resize(size_t(end - buf.data())); 79| 160| buf.append(" + body_length "); 80| 160| n = buf.size(); 81| 160| buf.resize(n + 24); 82| 160| end = glz::to_chars(buf.data() + n, body_length); 83| 160| buf.resize(size_t(end - buf.data())); 84| 160| buf.append(" exceed uint64_t"); 85| 160| return buf; 86| 160| } _ZN3glz6detail25build_invalid_query_errorENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE: 35| 2.09k| { 36| 2.09k| auto& buf = error_buffer(); 37| 2.09k| buf = "invalid_query: "; 38| 2.09k| buf.append(query); 39| 2.09k| return buf; 40| 2.09k| } _ZN3glz4repe22checked_message_lengthERKNS0_6headerERm: 52| 482k| { 53| 482k| constexpr uint64_t header_size = sizeof(header); 54| 482k| if (hdr.query_length > (std::numeric_limits::max)() - header_size) { ------------------ | Branch (54:11): [True: 12, False: 482k] ------------------ 55| 12| return false; 56| 12| } 57| 482k| const uint64_t header_and_query = header_size + hdr.query_length; 58| 482k| if (hdr.body_length > (std::numeric_limits::max)() - header_and_query) { ------------------ | Branch (58:11): [True: 308, False: 482k] ------------------ 59| 308| return false; 60| 308| } 61| 482k| expected = header_and_query + hdr.body_length; 62| 482k| return true; 63| 482k| } _ZN3glz4repe11plugin_callINS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EEEEE11repe_bufferRT_PKcm: 34| 13.2k| { 35| | // Use zero-copy span-based call - parses request in-place, writes directly to response buffer 36| | // Exception handling is done internally by the registry 37| 13.2k| registry.call(std::span{request, static_cast(request_size)}, plugin_response_buffer); 38| 13.2k| return {plugin_response_buffer.data(), plugin_response_buffer.size()}; 39| 13.2k| } _ZNK3glz6detail11string_hashclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE: 27| 7.85M| [[nodiscard]] size_t operator()(std::string_view txt) const { return std::hash{}(txt); } _ZNK3glz4repe10state_view8has_bodyEv: 556| 210k| [[nodiscard]] bool has_body() const noexcept { return !in.body.empty(); } _ZN3glz4repe16response_builder5resetERKNS0_12request_viewE: 373| 175k| void reset(const request_view& request) noexcept { reset(request.id()); } _ZN3glz4repe16response_builder5resetEm: 360| 202k| { 361| 202k| if (msg_) { ------------------ | Branch (361:14): [True: 0, False: 202k] ------------------ 362| 0| init_header(msg_->header, id); 363| 0| msg_->query.clear(); 364| 0| msg_->body.clear(); 365| 0| } 366| 202k| else { 367| 202k| buffer_->clear(); 368| 202k| init_header(hdr_, id); 369| 202k| } 370| 202k| } _ZN3glz4repe16response_builder11init_headerERNS0_6headerEm: 339| 202k| { 340| 202k| hdr = {}; 341| 202k| hdr.spec = repe_magic; 342| 202k| hdr.version = 1; 343| 202k| hdr.id = id; 344| 202k| } _ZNK3glz4repe12request_view2idEv: 256| 175k| [[nodiscard]] uint64_t id() const noexcept { return hdr.id; } _ZN3glz4repe16response_builder9set_errorENS_10error_codeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE: 377| 180k| { 378| 180k| if (msg_) { ------------------ | Branch (378:14): [True: 0, False: 180k] ------------------ 379| 0| msg_->header.ec = ec; 380| 0| msg_->header.body_format = body_format::UTF8; 381| 0| msg_->header.query_length = 0; 382| 0| msg_->header.body_length = error_message.size(); 383| 0| msg_->header.length = sizeof(header) + error_message.size(); 384| 0| msg_->query.clear(); 385| 0| msg_->body = error_message; 386| 0| } 387| 180k| else { 388| 180k| hdr_.ec = ec; 389| 180k| hdr_.body_format = body_format::UTF8; 390| 180k| hdr_.query_length = 0; 391| 180k| hdr_.body_length = error_message.size(); 392| 180k| hdr_.length = sizeof(header) + error_message.size(); 393| | 394| 180k| buffer_->resize(hdr_.length); 395| 180k| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 396| 180k| if (!error_message.empty()) { ------------------ | Branch (396:17): [True: 179k, False: 599] ------------------ 397| 179k| std::memcpy(buffer_->data() + sizeof(header), error_message.data(), error_message.size()); 398| 179k| } 399| 180k| } 400| 180k| } _ZNK3glz4repe10state_view6notifyEv: 555| 285k| [[nodiscard]] bool notify() const noexcept { return in.is_notify(); } _ZNK3glz4repe12request_view9is_notifyEv: 257| 291k| [[nodiscard]] bool is_notify() const noexcept { return hdr.notify != 0; } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEEEvRNS0_10state_viewE: 616| 19.7k| { 617| 19.7k| state.out.reset(state.in); 618| 19.7k| auto ec = state.out.template set_body(nullptr); 619| 19.7k| if (bool(ec)) [[unlikely]] { ------------------ | Branch (619:11): [True: 0, False: 19.7k] ------------------ 620| 0| state.out.set_error(ec, "Failed to serialize response"); 621| 0| } 622| 19.7k| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEDnEENS_10error_codeEOT0_: 413| 19.7k| { 414| 19.7k| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 19.7k] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 19.7k| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 19.7k| std::string body_buffer; 439| 19.7k| auto ec = glz::write(std::forward(value), body_buffer); 440| 19.7k| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 19.7k] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 19.7k| hdr_.ec = error_code::none; 445| 19.7k| if constexpr (Opts.format == JSON) { 446| 19.7k| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 19.7k| hdr_.query_length = 0; 455| 19.7k| hdr_.body_length = body_buffer.size(); 456| 19.7k| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 19.7k| buffer_->resize(hdr_.length); 460| 19.7k| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 19.7k| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 19.7k, False: 0] ------------------ 462| 19.7k| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 19.7k| } 464| 19.7k| return error_code::none; 465| 19.7k| } 466| 19.7k| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiEEbOT0_RNS0_10state_viewE: 568| 52.2k| { 569| 52.2k| glz::context ctx{}; 570| 52.2k| auto body = state.in.body; 571| 52.2k| auto b = body.data(); 572| 52.2k| auto e = b + body.size(); 573| 52.2k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 52.2k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 79, False: 52.2k] ------------------ 577| 79| ctx.error = error_code::no_read_input; 578| 79| } 579| 52.2k| else { 580| 52.2k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 52.2k| finalize_top_level_read(ctx, start, b, e); 583| 52.2k| } 584| | 585| 52.2k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 50.7k, False: 1.50k] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 50.7k| if (state.notify()) { ------------------ | Branch (588:14): [True: 20.2k, False: 30.4k] ------------------ 589| 20.2k| return false; 590| 20.2k| } 591| | 592| 30.4k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 30.4k| std::string error_message = format_error(ec, body); 594| 30.4k| state.out.reset(state.in); 595| 30.4k| state.out.set_error(ctx.error, error_message); 596| 30.4k| return false; 597| 50.7k| } 598| | 599| 1.50k| return true; 600| 52.2k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiEEvOT0_RNS0_10state_viewE: 605| 400| { 606| 400| state.out.reset(state.in); 607| 400| auto ec = state.out.template set_body(std::forward(value)); 608| 400| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 400] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 400| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERiEENS_10error_codeEOT0_: 413| 400| { 414| 400| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 400] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 400| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 400| std::string body_buffer; 439| 400| auto ec = glz::write(std::forward(value), body_buffer); 440| 400| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 400] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 400| hdr_.ec = error_code::none; 445| 400| if constexpr (Opts.format == JSON) { 446| 400| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 400| hdr_.query_length = 0; 455| 400| hdr_.body_length = body_buffer.size(); 456| 400| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 400| buffer_->resize(hdr_.length); 460| 400| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 400| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 400, False: 0] ------------------ 462| 400| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 400| } 464| 400| return error_code::none; 465| 400| } 466| 400| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiEEvOT0_RNS0_10state_viewE: 605| 353| { 606| 353| state.out.reset(state.in); 607| 353| auto ec = state.out.template set_body(std::forward(value)); 608| 353| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 353] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 353| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEiEENS_10error_codeEOT0_: 413| 353| { 414| 353| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 353] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 353| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 353| std::string body_buffer; 439| 353| auto ec = glz::write(std::forward(value), body_buffer); 440| 353| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 353] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 353| hdr_.ec = error_code::none; 445| 353| if constexpr (Opts.format == JSON) { 446| 353| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 353| hdr_.query_length = 0; 455| 353| hdr_.body_length = body_buffer.size(); 456| 353| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 353| buffer_->resize(hdr_.length); 460| 353| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 353| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 353, False: 0] ------------------ 462| 353| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 353| } 464| 353| return error_code::none; 465| 353| } 466| 353| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointEEEbOT0_RNS0_10state_viewE: 568| 39.2k| { 569| 39.2k| glz::context ctx{}; 570| 39.2k| auto body = state.in.body; 571| 39.2k| auto b = body.data(); 572| 39.2k| auto e = b + body.size(); 573| 39.2k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 39.2k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 79, False: 39.1k] ------------------ 577| 79| ctx.error = error_code::no_read_input; 578| 79| } 579| 39.1k| else { 580| 39.1k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 39.1k| finalize_top_level_read(ctx, start, b, e); 583| 39.1k| } 584| | 585| 39.2k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 39.0k, False: 233] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 39.0k| if (state.notify()) { ------------------ | Branch (588:14): [True: 15.4k, False: 23.6k] ------------------ 589| 15.4k| return false; 590| 15.4k| } 591| | 592| 23.6k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 23.6k| std::string error_message = format_error(ec, body); 594| 23.6k| state.out.reset(state.in); 595| 23.6k| state.out.set_error(ctx.error, error_message); 596| 23.6k| return false; 597| 39.0k| } 598| | 599| 233| return true; 600| 39.2k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointEEEvOT0_RNS0_10state_viewE: 605| 112| { 606| 112| state.out.reset(state.in); 607| 112| auto ec = state.out.template set_body(std::forward(value)); 608| 112| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 112] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 112| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointEEENS_10error_codeEOT0_: 413| 112| { 414| 112| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 112] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 112| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 112| std::string body_buffer; 439| 112| auto ec = glz::write(std::forward(value), body_buffer); 440| 112| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 112] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 112| hdr_.ec = error_code::none; 445| 112| if constexpr (Opts.format == JSON) { 446| 112| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 112| hdr_.query_length = 0; 455| 112| hdr_.body_length = body_buffer.size(); 456| 112| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 112| buffer_->resize(hdr_.length); 460| 112| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 112| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 112, False: 0] ------------------ 462| 112| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 112| } 464| 112| return error_code::none; 465| 112| } 466| 112| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedEEEbOT0_RNS0_10state_viewE: 568| 26.3k| { 569| 26.3k| glz::context ctx{}; 570| 26.3k| auto body = state.in.body; 571| 26.3k| auto b = body.data(); 572| 26.3k| auto e = b + body.size(); 573| 26.3k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 26.3k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 26.3k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 26.3k| else { 580| 26.3k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 26.3k| finalize_top_level_read(ctx, start, b, e); 583| 26.3k| } 584| | 585| 26.3k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 25.9k, False: 400] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 25.9k| if (state.notify()) { ------------------ | Branch (588:14): [True: 10.4k, False: 15.5k] ------------------ 589| 10.4k| return false; 590| 10.4k| } 591| | 592| 15.5k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 15.5k| std::string error_message = format_error(ec, body); 594| 15.5k| state.out.reset(state.in); 595| 15.5k| state.out.set_error(ctx.error, error_message); 596| 15.5k| return false; 597| 25.9k| } 598| | 599| 400| return true; 600| 26.3k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvOT0_RNS0_10state_viewE: 605| 247| { 606| 247| state.out.reset(state.in); 607| 247| auto ec = state.out.template set_body(std::forward(value)); 608| 247| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 247] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 247| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS_10error_codeEOT0_: 413| 247| { 414| 247| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 247] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 247| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 247| std::string body_buffer; 439| 247| auto ec = glz::write(std::forward(value), body_buffer); 440| 247| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 247] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 247| hdr_.ec = error_code::none; 445| 247| if constexpr (Opts.format == JSON) { 446| 247| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 247| hdr_.query_length = 0; 455| 247| hdr_.body_length = body_buffer.size(); 456| 247| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 247| buffer_->resize(hdr_.length); 460| 247| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 247| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 247, False: 0] ------------------ 462| 247| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 247| } 464| 247| return error_code::none; 465| 247| } 466| 247| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiEEEbOT0_RNS0_10state_viewE: 568| 22.0k| { 569| 22.0k| glz::context ctx{}; 570| 22.0k| auto body = state.in.body; 571| 22.0k| auto b = body.data(); 572| 22.0k| auto e = b + body.size(); 573| 22.0k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 22.0k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 22.0k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 22.0k| else { 580| 22.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 22.0k| finalize_top_level_read(ctx, start, b, e); 583| 22.0k| } 584| | 585| 22.0k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 22.0k, False: 52] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 22.0k| if (state.notify()) { ------------------ | Branch (588:14): [True: 8.56k, False: 13.4k] ------------------ 589| 8.56k| return false; 590| 8.56k| } 591| | 592| 13.4k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 13.4k| std::string error_message = format_error(ec, body); 594| 13.4k| state.out.reset(state.in); 595| 13.4k| state.out.set_error(ctx.error, error_message); 596| 13.4k| return false; 597| 22.0k| } 598| | 599| 52| return true; 600| 22.0k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiEEEvOT0_RNS0_10state_viewE: 605| 47| { 606| 47| state.out.reset(state.in); 607| 47| auto ec = state.out.template set_body(std::forward(value)); 608| 47| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 47] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 47| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz8fuzz_apiEEENS_10error_codeEOT0_: 413| 47| { 414| 47| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 47] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 47| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 47| std::string body_buffer; 439| 47| auto ec = glz::write(std::forward(value), body_buffer); 440| 47| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 47] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 47| hdr_.ec = error_code::none; 445| 47| if constexpr (Opts.format == JSON) { 446| 47| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 47| hdr_.query_length = 0; 455| 47| hdr_.body_length = body_buffer.size(); 456| 47| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 47| buffer_->resize(hdr_.length); 460| 47| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 47| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 47, False: 0] ------------------ 462| 47| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 47| } 464| 47| return error_code::none; 465| 47| } 466| 47| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEbOT0_RNS0_10state_viewE: 568| 39.3k| { 569| 39.3k| glz::context ctx{}; 570| 39.3k| auto body = state.in.body; 571| 39.3k| auto b = body.data(); 572| 39.3k| auto e = b + body.size(); 573| 39.3k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 39.3k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 79, False: 39.2k] ------------------ 577| 79| ctx.error = error_code::no_read_input; 578| 79| } 579| 39.2k| else { 580| 39.2k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 39.2k| finalize_top_level_read(ctx, start, b, e); 583| 39.2k| } 584| | 585| 39.3k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 38.0k, False: 1.33k] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 38.0k| if (state.notify()) { ------------------ | Branch (588:14): [True: 14.9k, False: 23.0k] ------------------ 589| 14.9k| return false; 590| 14.9k| } 591| | 592| 23.0k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 23.0k| std::string error_message = format_error(ec, body); 594| 23.0k| state.out.reset(state.in); 595| 23.0k| state.out.set_error(ctx.error, error_message); 596| 23.0k| return false; 597| 38.0k| } 598| | 599| 1.33k| return true; 600| 39.3k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvOT0_RNS0_10state_viewE: 605| 367| { 606| 367| state.out.reset(state.in); 607| 367| auto ec = state.out.template set_body(std::forward(value)); 608| 367| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 367] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 367| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEENS_10error_codeEOT0_: 413| 367| { 414| 367| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 367] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 367| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 367| std::string body_buffer; 439| 367| auto ec = glz::write(std::forward(value), body_buffer); 440| 367| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 367] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 367| hdr_.ec = error_code::none; 445| 367| if constexpr (Opts.format == JSON) { 446| 367| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 367| hdr_.query_length = 0; 455| 367| hdr_.body_length = body_buffer.size(); 456| 367| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 367| buffer_->resize(hdr_.length); 460| 367| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 367| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 367, False: 0] ------------------ 462| 367| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 367| } 464| 367| return error_code::none; 465| 367| } 466| 367| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdEEbOT0_RNS0_10state_viewE: 568| 13.0k| { 569| 13.0k| glz::context ctx{}; 570| 13.0k| auto body = state.in.body; 571| 13.0k| auto b = body.data(); 572| 13.0k| auto e = b + body.size(); 573| 13.0k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.0k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 13.0k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 13.0k| else { 580| 13.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.0k| finalize_top_level_read(ctx, start, b, e); 583| 13.0k| } 584| | 585| 13.0k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 11.5k, False: 1.48k] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 11.5k| if (state.notify()) { ------------------ | Branch (588:14): [True: 4.63k, False: 6.93k] ------------------ 589| 4.63k| return false; 590| 4.63k| } 591| | 592| 6.93k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 6.93k| std::string error_message = format_error(ec, body); 594| 6.93k| state.out.reset(state.in); 595| 6.93k| state.out.set_error(ctx.error, error_message); 596| 6.93k| return false; 597| 11.5k| } 598| | 599| 1.48k| return true; 600| 13.0k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdEEvOT0_RNS0_10state_viewE: 605| 444| { 606| 444| state.out.reset(state.in); 607| 444| auto ec = state.out.template set_body(std::forward(value)); 608| 444| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 444] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 444| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERdEENS_10error_codeEOT0_: 413| 444| { 414| 444| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 444] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 444| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 444| std::string body_buffer; 439| 444| auto ec = glz::write(std::forward(value), body_buffer); 440| 444| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 444] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 444| hdr_.ec = error_code::none; 445| 444| if constexpr (Opts.format == JSON) { 446| 444| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 444| hdr_.query_length = 0; 455| 444| hdr_.body_length = body_buffer.size(); 456| 444| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 444| buffer_->resize(hdr_.length); 460| 444| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 444| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 444, False: 0] ------------------ 462| 444| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 444| } 464| 444| return error_code::none; 465| 444| } 466| 444| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointEEEvOT0_RNS0_10state_viewE: 605| 113| { 606| 113| state.out.reset(state.in); 607| 113| auto ec = state.out.template set_body(std::forward(value)); 608| 113| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 113] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 113| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz5pointEEENS_10error_codeEOT0_: 413| 113| { 414| 113| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 113] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 113| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 113| std::string body_buffer; 439| 113| auto ec = glz::write(std::forward(value), body_buffer); 440| 113| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 113] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 113| hdr_.ec = error_code::none; 445| 113| if constexpr (Opts.format == JSON) { 446| 113| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 113| hdr_.query_length = 0; 455| 113| hdr_.body_length = body_buffer.size(); 456| 113| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 113| buffer_->resize(hdr_.length); 460| 113| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 113| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 113, False: 0] ------------------ 462| 113| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 113| } 464| 113| return error_code::none; 465| 113| } 466| 113| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedEEEvOT0_RNS0_10state_viewE: 605| 44| { 606| 44| state.out.reset(state.in); 607| 44| auto ec = state.out.template set_body(std::forward(value)); 608| 44| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 44] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 44| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERN9repe_fuzz6nestedEEENS_10error_codeEOT0_: 413| 44| { 414| 44| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 44] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 44| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 44| std::string body_buffer; 439| 44| auto ec = glz::write(std::forward(value), body_buffer); 440| 44| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 44] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 44| hdr_.ec = error_code::none; 445| 44| if constexpr (Opts.format == JSON) { 446| 44| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 44| hdr_.query_length = 0; 455| 44| hdr_.body_length = body_buffer.size(); 456| 44| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 44| buffer_->resize(hdr_.length); 460| 44| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 44| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 44, False: 0] ------------------ 462| 44| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 44| } 464| 44| return error_code::none; 465| 44| } 466| 44| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEEEEbOT0_RNS0_10state_viewE: 568| 13.0k| { 569| 13.0k| glz::context ctx{}; 570| 13.0k| auto body = state.in.body; 571| 13.0k| auto b = body.data(); 572| 13.0k| auto e = b + body.size(); 573| 13.0k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.0k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 13.0k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 13.0k| else { 580| 13.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.0k| finalize_top_level_read(ctx, start, b, e); 583| 13.0k| } 584| | 585| 13.0k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 13.0k, False: 72] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 13.0k| if (state.notify()) { ------------------ | Branch (588:14): [True: 5.14k, False: 7.85k] ------------------ 589| 5.14k| return false; 590| 5.14k| } 591| | 592| 7.85k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 7.85k| std::string error_message = format_error(ec, body); 594| 7.85k| state.out.reset(state.in); 595| 7.85k| state.out.set_error(ctx.error, error_message); 596| 7.85k| return false; 597| 13.0k| } 598| | 599| 72| return true; 600| 13.0k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS3_9allocatorIiEEEEEEvOT0_RNS0_10state_viewE: 605| 44| { 606| 44| state.out.reset(state.in); 607| 44| auto ec = state.out.template set_body(std::forward(value)); 608| 44| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 44] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 44| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIiNS4_9allocatorIiEEEEEENS_10error_codeEOT0_: 413| 44| { 414| 44| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 44] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 44| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 44| std::string body_buffer; 439| 44| auto ec = glz::write(std::forward(value), body_buffer); 440| 44| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 44] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 44| hdr_.ec = error_code::none; 445| 44| if constexpr (Opts.format == JSON) { 446| 44| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 44| hdr_.query_length = 0; 455| 44| hdr_.body_length = body_buffer.size(); 456| 44| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 44| buffer_->resize(hdr_.length); 460| 44| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 44| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 44, False: 0] ------------------ 462| 44| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 44| } 464| 44| return error_code::none; 465| 44| } 466| 44| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEEEEbOT0_RNS0_10state_viewE: 568| 13.1k| { 569| 13.1k| glz::context ctx{}; 570| 13.1k| auto body = state.in.body; 571| 13.1k| auto b = body.data(); 572| 13.1k| auto e = b + body.size(); 573| 13.1k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.1k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 13.1k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 13.1k| else { 580| 13.1k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.1k| finalize_top_level_read(ctx, start, b, e); 583| 13.1k| } 584| | 585| 13.1k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 13.1k, False: 40] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 13.1k| if (state.notify()) { ------------------ | Branch (588:14): [True: 5.15k, False: 7.99k] ------------------ 589| 5.15k| return false; 590| 5.15k| } 591| | 592| 7.99k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 7.99k| std::string error_message = format_error(ec, body); 594| 7.99k| state.out.reset(state.in); 595| 7.99k| state.out.set_error(ctx.error, error_message); 596| 7.99k| return false; 597| 13.1k| } 598| | 599| 40| return true; 600| 13.1k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiNS3_4lessISA_EENS8_INS3_4pairIKSA_iEEEEEEEEvOT0_RNS0_10state_viewE: 605| 44| { 606| 44| state.out.reset(state.in); 607| 44| auto ec = state.out.template set_body(std::forward(value)); 608| 44| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 44] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 44| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEEEENS_10error_codeEOT0_: 413| 44| { 414| 44| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 44] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 44| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 44| std::string body_buffer; 439| 44| auto ec = glz::write(std::forward(value), body_buffer); 440| 44| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 44] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 44| hdr_.ec = error_code::none; 445| 44| if constexpr (Opts.format == JSON) { 446| 44| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 44| hdr_.query_length = 0; 455| 44| hdr_.body_length = body_buffer.size(); 456| 44| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 44| buffer_->resize(hdr_.length); 460| 44| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 44| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 44, False: 0] ------------------ 462| 44| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 44| } 464| 44| return error_code::none; 465| 44| } 466| 44| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEEEEbOT0_RNS0_10state_viewE: 568| 13.0k| { 569| 13.0k| glz::context ctx{}; 570| 13.0k| auto body = state.in.body; 571| 13.0k| auto b = body.data(); 572| 13.0k| auto e = b + body.size(); 573| 13.0k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.0k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 13.0k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 13.0k| else { 580| 13.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.0k| finalize_top_level_read(ctx, start, b, e); 583| 13.0k| } 584| | 585| 13.0k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 11.5k, False: 1.48k] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 11.5k| if (state.notify()) { ------------------ | Branch (588:14): [True: 4.63k, False: 6.93k] ------------------ 589| 4.63k| return false; 590| 4.63k| } 591| | 592| 6.93k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 6.93k| std::string error_message = format_error(ec, body); 594| 6.93k| state.out.reset(state.in); 595| 6.93k| state.out.set_error(ctx.error, error_message); 596| 6.93k| return false; 597| 11.5k| } 598| | 599| 1.48k| return true; 600| 13.0k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEEEEvOT0_RNS0_10state_viewE: 605| 44| { 606| 44| state.out.reset(state.in); 607| 44| auto ec = state.out.template set_body(std::forward(value)); 608| 44| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 44] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 44| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__18optionalIdEEEENS_10error_codeEOT0_: 413| 44| { 414| 44| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 44] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 44| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 44| std::string body_buffer; 439| 44| auto ec = glz::write(std::forward(value), body_buffer); 440| 44| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 44] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 44| hdr_.ec = error_code::none; 445| 44| if constexpr (Opts.format == JSON) { 446| 44| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 44| hdr_.query_length = 0; 455| 44| hdr_.body_length = body_buffer.size(); 456| 44| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 44| buffer_->resize(hdr_.length); 460| 44| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 44| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 44, False: 0] ------------------ 462| 44| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 44| } 464| 44| return error_code::none; 465| 44| } 466| 44| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN9repe_fuzz6amountEEEEEEbOT0_RNS0_10state_viewE: 568| 13.0k| { 569| 13.0k| glz::context ctx{}; 570| 13.0k| auto body = state.in.body; 571| 13.0k| auto b = body.data(); 572| 13.0k| auto e = b + body.size(); 573| 13.0k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.0k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 0, False: 13.0k] ------------------ 577| 0| ctx.error = error_code::no_read_input; 578| 0| } 579| 13.0k| else { 580| 13.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.0k| finalize_top_level_read(ctx, start, b, e); 583| 13.0k| } 584| | 585| 13.0k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 12.6k, False: 463] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 12.6k| if (state.notify()) { ------------------ | Branch (588:14): [True: 4.97k, False: 7.63k] ------------------ 589| 4.97k| return false; 590| 4.97k| } 591| | 592| 7.63k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 7.63k| std::string error_message = format_error(ec, body); 594| 7.63k| state.out.reset(state.in); 595| 7.63k| state.out.set_error(ctx.error, error_message); 596| 7.63k| return false; 597| 12.6k| } 598| | 599| 463| return true; 600| 13.0k| } _ZN3glz4repe14write_responseITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEN9repe_fuzz6amountEEEEEEvOT0_RNS0_10state_viewE: 605| 44| { 606| 44| state.out.reset(state.in); 607| 44| auto ec = state.out.template set_body(std::forward(value)); 608| 44| if (bool(ec)) [[unlikely]] { ------------------ | Branch (608:11): [True: 0, False: 44] ------------------ 609| 0| state.out.set_error(ec, "Failed to serialize response"); 610| 0| } 611| 44| } _ZN3glz4repe16response_builder8set_bodyITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN9repe_fuzz6amountEEEEEENS_10error_codeEOT0_: 413| 44| { 414| 44| if (msg_) { ------------------ | Branch (414:14): [True: 0, False: 44] ------------------ 415| | // Write directly to message body 416| 0| auto ec = glz::write(std::forward(value), msg_->body); 417| 0| if (ec) { ------------------ | Branch (417:17): [True: 0, False: 0] ------------------ 418| 0| return ec.ec; 419| 0| } 420| | 421| 0| msg_->header.ec = error_code::none; 422| 0| if constexpr (Opts.format == JSON) { 423| 0| msg_->header.body_format = body_format::JSON; 424| | } 425| | else if constexpr (Opts.format == BEVE) { 426| | msg_->header.body_format = body_format::BEVE; 427| | } 428| | else { 429| | msg_->header.body_format = body_format::JSON; 430| | } 431| 0| msg_->header.query_length = 0; 432| 0| msg_->header.body_length = msg_->body.size(); 433| 0| msg_->header.length = sizeof(header) + msg_->body.size(); 434| 0| return error_code::none; 435| 0| } 436| 44| else { 437| | // Serialize body to temporary buffer first (glz::write clears the buffer) 438| 44| std::string body_buffer; 439| 44| auto ec = glz::write(std::forward(value), body_buffer); 440| 44| if (ec) { ------------------ | Branch (440:17): [True: 0, False: 44] ------------------ 441| 0| return ec.ec; 442| 0| } 443| | 444| 44| hdr_.ec = error_code::none; 445| 44| if constexpr (Opts.format == JSON) { 446| 44| hdr_.body_format = body_format::JSON; 447| | } 448| | else if constexpr (Opts.format == BEVE) { 449| | hdr_.body_format = body_format::BEVE; 450| | } 451| | else { 452| | hdr_.body_format = body_format::JSON; 453| | } 454| 44| hdr_.query_length = 0; 455| 44| hdr_.body_length = body_buffer.size(); 456| 44| hdr_.length = sizeof(header) + body_buffer.size(); 457| | 458| | // Write header then body 459| 44| buffer_->resize(hdr_.length); 460| 44| std::memcpy(buffer_->data(), &hdr_, sizeof(header)); 461| 44| if (!body_buffer.empty()) { ------------------ | Branch (461:17): [True: 44, False: 0] ------------------ 462| 44| std::memcpy(buffer_->data() + sizeof(header), body_buffer.data(), body_buffer.size()); 463| 44| } 464| 44| return error_code::none; 465| 44| } 466| 44| } _ZN3glz4repe11read_paramsITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERNSt3__16vectorIdNS3_9allocatorIdEEEEEEbOT0_RNS0_10state_viewE: 568| 13.1k| { 569| 13.1k| glz::context ctx{}; 570| 13.1k| auto body = state.in.body; 571| 13.1k| auto b = body.data(); 572| 13.1k| auto e = b + body.size(); 573| 13.1k| auto start = b; 574| | 575| | // An empty body answers like any other failure; see the note in the message overload above. 576| 13.1k| if (body.empty()) [[unlikely]] { ------------------ | Branch (576:11): [True: 79, False: 13.0k] ------------------ 577| 79| ctx.error = error_code::no_read_input; 578| 79| } 579| 13.0k| else { 580| 13.0k| glz::parse::template op()>(std::forward(value), ctx, b, e); 581| | // See the note in the message overload above for why glz::read's bookkeeping is repeated. 582| 13.0k| finalize_top_level_read(ctx, start, b, e); 583| 13.0k| } 584| | 585| 13.1k| if (bool(ctx.error)) { ------------------ | Branch (585:11): [True: 12.7k, False: 408] ------------------ 586| | // A notification is a request the sender has said it will not read a reply to, so a failed 587| | // read of one is reported by not answering, exactly as a successful read of one is. 588| 12.7k| if (state.notify()) { ------------------ | Branch (588:14): [True: 5.15k, False: 7.57k] ------------------ 589| 5.15k| return false; 590| 5.15k| } 591| | 592| 7.57k| error_ctx ec{size_t(b - start), ctx.error, ctx.custom_error_message}; 593| 7.57k| std::string error_message = format_error(ec, body); 594| 7.57k| state.out.reset(state.in); 595| 7.57k| state.out.set_error(ctx.error, error_message); 596| 7.57k| return false; 597| 12.7k| } 598| | 599| 408| return true; 600| 13.1k| } _ZN3glz4repe16response_builderC2ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 347| 318k| explicit response_builder(std::string& buffer) noexcept : buffer_(&buffer) {} _ZNK3glz4repe12parse_resultcvbEv: 268| 318k| [[nodiscard]] explicit operator bool() const noexcept { return ec == error_code::none; } _ZN3glz4repe13parse_requestENSt3__14spanIKcLm18446744073709551615EEE: 277| 507k| { 278| 507k| parse_result result{}; 279| | 280| 507k| if (buffer.size() < sizeof(header)) { ------------------ | Branch (280:11): [True: 17.7k, False: 489k] ------------------ 281| 17.7k| result.ec = error_code::invalid_header; 282| 17.7k| return result; 283| 17.7k| } 284| | 285| | // Copy header via memcpy for alignment safety (48 bytes, ~2-5ns) 286| 489k| std::memcpy(&result.request.hdr, buffer.data(), sizeof(header)); 287| | 288| 489k| if (result.request.hdr.spec != repe_magic) { ------------------ | Branch (288:11): [True: 7.83k, False: 481k] ------------------ 289| 7.83k| result.ec = error_code::invalid_header; 290| 7.83k| return result; 291| 7.83k| } 292| | 293| 481k| if (result.request.hdr.version != 1) { ------------------ | Branch (293:11): [True: 26, False: 481k] ------------------ 294| 26| result.ec = error_code::version_mismatch; 295| 26| return result; 296| 26| } 297| | 298| 481k| const auto& hdr = result.request.hdr; 299| 481k| uint64_t expected_length{}; 300| 481k| if (!checked_message_length(hdr, expected_length)) { ------------------ | Branch (300:11): [True: 160, False: 481k] ------------------ 301| 160| result.ec = error_code::invalid_header; 302| 160| return result; 303| 160| } 304| | 305| | // Validate header.length field matches expected value 306| 481k| if (hdr.length != expected_length) { ------------------ | Branch (306:11): [True: 584, False: 480k] ------------------ 307| 584| result.ec = error_code::invalid_header; 308| 584| return result; 309| 584| } 310| | 311| 480k| if (uint64_t(buffer.size()) < expected_length) { ------------------ | Branch (311:11): [True: 64, False: 480k] ------------------ 312| 64| result.ec = error_code::invalid_body; 313| 64| return result; 314| 64| } 315| | 316| | // Set up views into the original buffer 317| 480k| result.request.query = {buffer.data() + sizeof(header), static_cast(hdr.query_length)}; 318| 480k| result.request.body = {buffer.data() + sizeof(header) + hdr.query_length, static_cast(hdr.body_length)}; 319| 480k| result.ec = error_code::none; 320| | 321| 480k| return result; 322| 480k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE17register_endpointIN9repe_fuzz10member_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 27| 304k| { 28| 304k| reg.endpoints[path] = [&value](repe::state_view& state) mutable { 29| 304k| if (state.has_body()) { 30| 304k| if (!read_params(value, state)) { 31| 304k| return; 32| 304k| } 33| 304k| } 34| | 35| 304k| if (state.notify()) { 36| 304k| return; 37| 304k| } 38| | 39| 304k| if (not state.has_body()) { 40| 304k| write_response(value, state); 41| 304k| } 42| 304k| else { 43| 304k| write_response(state); 44| 304k| } 45| 304k| }; 46| 304k| } _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 151| 941k| { 152| 941k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 941k| if (state.has_body()) { 154| 941k| if (!read_params(var, state)) { 155| 941k| return; 156| 941k| } 157| 941k| } 158| | 159| 941k| if (state.notify()) { 160| 941k| return; 161| 941k| } 162| | 163| 941k| if (not state.has_body()) { 164| 941k| write_response(var, state); 165| 941k| } 166| 941k| else { 167| 941k| write_response(state); 168| 941k| } 169| 941k| }; 170| 941k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointIiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESH_: 152| 26.2k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 26.2k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 26.1k, False: 156] ------------------ 154| 26.1k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 25.3k, False: 749] ------------------ 155| 25.3k| return; 156| 25.3k| } 157| 26.1k| } 158| | 159| 905| if (state.notify()) { ------------------ | Branch (159:17): [True: 198, False: 707] ------------------ 160| 198| return; 161| 198| } 162| | 163| 707| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 87, False: 620] ------------------ 164| 87| write_response(var, state); 165| 87| } 166| 620| else { 167| 620| write_response(state); 168| 620| } 169| 707| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_: 198| 304k| { 199| 304k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 304k| static thread_local Input input{}; 201| 304k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 304k| if (state.has_body()) { 203| 304k| if (!read_params(input, state)) { 204| 304k| return; 205| 304k| } 206| 304k| } 207| | 208| 304k| if constexpr (std::same_as) { 209| 304k| (value.*func)(input); 210| | 211| 304k| if (state.notify()) { 212| 304k| return; 213| 304k| } 214| | 215| 304k| write_response(state); 216| 304k| } 217| 304k| else { 218| 304k| if (state.notify()) { 219| 304k| std::ignore = (value.*func)(input); 220| 304k| return; 221| 304k| } 222| | 223| 304k| write_response((value.*func)(input), state); 224| 304k| } 225| 304k| }; 226| 304k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FiiEiiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT3_ENUlRNS_4repe10state_viewEE_clESM_: 199| 13.1k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 13.1k| static thread_local Input input{}; 201| 13.1k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 13.1k| if (state.has_body()) { ------------------ | Branch (202:17): [True: 13.0k, False: 79] ------------------ 203| 13.0k| if (!read_params(input, state)) { ------------------ | Branch (203:20): [True: 12.6k, False: 373] ------------------ 204| 12.6k| return; 205| 12.6k| } 206| 13.0k| } 207| | 208| | if constexpr (std::same_as) { 209| | (value.*func)(input); 210| | 211| | if (state.notify()) { 212| | return; 213| | } 214| | 215| | write_response(state); 216| | } 217| 452| else { 218| 452| if (state.notify()) { ------------------ | Branch (218:20): [True: 99, False: 353] ------------------ 219| 99| std::ignore = (value.*func)(input); 220| 99| return; 221| 99| } 222| | 223| 353| write_response((value.*func)(input), state); 224| 353| } 225| 452| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE33register_member_function_endpointIN9repe_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_: 174| 304k| { 175| 304k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 176| 304k| if constexpr (std::same_as) { 177| 304k| (value.*func)(); 178| | 179| 304k| if (state.notify()) { 180| 304k| return; 181| 304k| } 182| | 183| 304k| write_response(state); 184| 304k| } 185| 304k| else { 186| 304k| if (state.notify()) { 187| 304k| std::ignore = (value.*func)(); 188| 304k| return; 189| 304k| } 190| | 191| 304k| write_response((value.*func)(), state); 192| 304k| } 193| 304k| }; 194| 304k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE33register_member_function_endpointIN9repe_fuzz10member_apiEMS5_FvvEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSA_11char_traitsIcEEEERT_T0_RT2_ENUlRNS_4repe10state_viewEE_clESM_: 175| 13.1k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 176| 13.1k| if constexpr (std::same_as) { 177| 13.1k| (value.*func)(); 178| | 179| 13.1k| if (state.notify()) { ------------------ | Branch (179:20): [True: 5.16k, False: 7.96k] ------------------ 180| 5.16k| return; 181| 5.16k| } 182| | 183| 7.96k| write_response(state); 184| | } 185| | else { 186| | if (state.notify()) { 187| | std::ignore = (value.*func)(); 188| | return; 189| | } 190| | 191| | write_response((value.*func)(), state); 192| | } 193| 13.1k| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_: 198| 304k| { 199| 304k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 304k| static thread_local Input input{}; 201| 304k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 304k| if (state.has_body()) { 203| 304k| if (!read_params(input, state)) { 204| 304k| return; 205| 304k| } 206| 304k| } 207| | 208| 304k| if constexpr (std::same_as) { 209| 304k| (value.*func)(input); 210| | 211| 304k| if (state.notify()) { 212| 304k| return; 213| 304k| } 214| | 215| 304k| write_response(state); 216| 304k| } 217| 304k| else { 218| 304k| if (state.notify()) { 219| 304k| std::ignore = (value.*func)(input); 220| 304k| return; 221| 304k| } 222| | 223| 304k| write_response((value.*func)(input), state); 224| 304k| } 225| 304k| }; 226| 304k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FNS4_5pointERKS6_ES6_S6_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNSD_11char_traitsIcEEEERT_T0_RT3_ENUlRNS_4repe10state_viewEE_clESP_: 199| 13.1k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 13.1k| static thread_local Input input{}; 201| 13.1k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 13.1k| if (state.has_body()) { ------------------ | Branch (202:17): [True: 13.0k, False: 78] ------------------ 203| 13.0k| if (!read_params(input, state)) { ------------------ | Branch (203:20): [True: 13.0k, False: 77] ------------------ 204| 13.0k| return; 205| 13.0k| } 206| 13.0k| } 207| | 208| | if constexpr (std::same_as) { 209| | (value.*func)(input); 210| | 211| | if (state.notify()) { 212| | return; 213| | } 214| | 215| | write_response(state); 216| | } 217| 155| else { 218| 155| if (state.notify()) { ------------------ | Branch (218:20): [True: 43, False: 112] ------------------ 219| 43| std::ignore = (value.*func)(input); 220| 43| return; 221| 43| } 222| | 223| 112| write_response((value.*func)(input), state); 224| 112| } 225| 155| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEERKNS4_6nestedEESD_SC_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS6_17basic_string_viewIcS9_EERT_T0_RT3_: 198| 304k| { 199| 304k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 304k| static thread_local Input input{}; 201| 304k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 304k| if (state.has_body()) { 203| 304k| if (!read_params(input, state)) { 204| 304k| return; 205| 304k| } 206| 304k| } 207| | 208| 304k| if constexpr (std::same_as) { 209| 304k| (value.*func)(input); 210| | 211| 304k| if (state.notify()) { 212| 304k| return; 213| 304k| } 214| | 215| 304k| write_response(state); 216| 304k| } 217| 304k| else { 218| 304k| if (state.notify()) { 219| 304k| std::ignore = (value.*func)(input); 220| 304k| return; 221| 304k| } 222| | 223| 304k| write_response((value.*func)(input), state); 224| 304k| } 225| 304k| }; 226| 304k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE45register_member_function_with_params_endpointIN9repe_fuzz10member_apiEMS5_FNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEERKNS4_6nestedEESD_SC_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS6_17basic_string_viewIcS9_EERT_T0_RT3_ENUlRNS_4repe10state_viewEE_clEST_: 199| 13.3k| reg.endpoints[path] = [&value, func](repe::state_view& state) mutable { 200| 13.3k| static thread_local Input input{}; 201| 13.3k| input = {}; // reset to avoid stale optional/variant fields across calls 202| 13.3k| if (state.has_body()) { ------------------ | Branch (202:17): [True: 13.2k, False: 79] ------------------ 203| 13.2k| if (!read_params(input, state)) { ------------------ | Branch (203:20): [True: 13.0k, False: 218] ------------------ 204| 13.0k| return; 205| 13.0k| } 206| 13.2k| } 207| | 208| | if constexpr (std::same_as) { 209| | (value.*func)(input); 210| | 211| | if (state.notify()) { 212| | return; 213| | } 214| | 215| | write_response(state); 216| | } 217| 297| else { 218| 297| if (state.notify()) { ------------------ | Branch (218:20): [True: 50, False: 247] ------------------ 219| 50| std::ignore = (value.*func)(input); 220| 50| return; 221| 50| } 222| | 223| 247| write_response((value.*func)(input), state); 224| 247| } 225| 297| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE17register_endpointIN9repe_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 27| 318k| { 28| 318k| reg.endpoints[path] = [&value](repe::state_view& state) mutable { 29| 318k| if (state.has_body()) { 30| 318k| if (!read_params(value, state)) { 31| 318k| return; 32| 318k| } 33| 318k| } 34| | 35| 318k| if (state.notify()) { 36| 318k| return; 37| 318k| } 38| | 39| 318k| if (not state.has_body()) { 40| 318k| write_response(value, state); 41| 318k| } 42| 318k| else { 43| 318k| write_response(state); 44| 318k| } 45| 318k| }; 46| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE17register_endpointIN9repe_fuzz8fuzz_apiENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESJ_: 28| 22.1k| reg.endpoints[path] = [&value](repe::state_view& state) mutable { 29| 22.1k| if (state.has_body()) { ------------------ | Branch (29:17): [True: 22.0k, False: 92] ------------------ 30| 22.0k| if (!read_params(value, state)) { ------------------ | Branch (30:20): [True: 22.0k, False: 52] ------------------ 31| 22.0k| return; 32| 22.0k| } 33| 22.0k| } 34| | 35| 144| if (state.notify()) { ------------------ | Branch (35:17): [True: 59, False: 85] ------------------ 36| 59| return; 37| 59| } 38| | 39| 85| if (not state.has_body()) { ------------------ | Branch (39:17): [True: 47, False: 38] ------------------ 40| 47| write_response(value, state); 41| 47| } 42| 38| else { 43| 38| write_response(state); 44| 38| } 45| 85| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_: 151| 636k| { 152| 636k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 636k| if (state.has_body()) { 154| 636k| if (!read_params(var, state)) { 155| 636k| return; 156| 636k| } 157| 636k| } 158| | 159| 636k| if (state.notify()) { 160| 636k| return; 161| 636k| } 162| | 163| 636k| if (not state.has_body()) { 164| 636k| write_response(var, state); 165| 636k| } 166| 636k| else { 167| 636k| write_response(state); 168| 636k| } 169| 636k| }; 170| 636k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS7_EERT_RT0_ENUlRNS_4repe10state_viewEE_clESL_: 152| 26.3k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 26.3k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 26.2k, False: 156] ------------------ 154| 26.2k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 25.3k, False: 885] ------------------ 155| 25.3k| return; 156| 25.3k| } 157| 26.2k| } 158| | 159| 1.04k| if (state.notify()) { ------------------ | Branch (159:17): [True: 411, False: 630] ------------------ 160| 411| return; 161| 411| } 162| | 163| 630| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 87, False: 543] ------------------ 164| 87| write_response(var, state); 165| 87| } 166| 543| else { 167| 543| write_response(state); 168| 543| } 169| 630| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_: 151| 636k| { 152| 636k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 636k| if (state.has_body()) { 154| 636k| if (!read_params(var, state)) { 155| 636k| return; 156| 636k| } 157| 636k| } 158| | 159| 636k| if (state.notify()) { 160| 636k| return; 161| 636k| } 162| | 163| 636k| if (not state.has_body()) { 164| 636k| write_response(var, state); 165| 636k| } 166| 636k| else { 167| 636k| write_response(state); 168| 636k| } 169| 636k| }; 170| 636k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointIdNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESH_: 152| 13.1k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 13.1k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 13.0k, False: 79] ------------------ 154| 13.0k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 11.5k, False: 1.48k] ------------------ 155| 11.5k| return; 156| 11.5k| } 157| 13.0k| } 158| | 159| 1.56k| if (state.notify()) { ------------------ | Branch (159:17): [True: 533, False: 1.02k] ------------------ 160| 533| return; 161| 533| } 162| | 163| 1.02k| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 44, False: 983] ------------------ 164| 44| write_response(var, state); 165| 44| } 166| 983| else { 167| 983| write_response(state); 168| 983| } 169| 1.02k| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE24register_object_endpointIN9repe_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 105| 318k| { 106| 318k| reg.endpoints[path] = [&obj](repe::state_view& state) mutable { 107| 318k| if (state.has_body()) { 108| 318k| if (!read_params(obj, state)) { 109| 318k| return; 110| 318k| } 111| 318k| } 112| | 113| 318k| if (state.notify()) { 114| 318k| return; 115| 318k| } 116| | 117| 318k| if (not state.has_body()) { 118| 318k| write_response(obj, state); 119| 318k| } 120| 318k| else { 121| 318k| write_response(state); 122| 318k| } 123| 318k| }; 124| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE24register_object_endpointIN9repe_fuzz5pointENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESJ_: 106| 13.1k| reg.endpoints[path] = [&obj](repe::state_view& state) mutable { 107| 13.1k| if (state.has_body()) { ------------------ | Branch (107:17): [True: 13.0k, False: 78] ------------------ 108| 13.0k| if (!read_params(obj, state)) { ------------------ | Branch (108:20): [True: 12.9k, False: 78] ------------------ 109| 12.9k| return; 110| 12.9k| } 111| 13.0k| } 112| | 113| 156| if (state.notify()) { ------------------ | Branch (113:17): [True: 43, False: 113] ------------------ 114| 43| return; 115| 43| } 116| | 117| 113| if (not state.has_body()) { ------------------ | Branch (117:17): [True: 44, False: 69] ------------------ 118| 44| write_response(obj, state); 119| 44| } 120| 69| else { 121| 69| write_response(state); 122| 69| } 123| 113| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE24register_object_endpointIN9repe_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_: 105| 318k| { 106| 318k| reg.endpoints[path] = [&obj](repe::state_view& state) mutable { 107| 318k| if (state.has_body()) { 108| 318k| if (!read_params(obj, state)) { 109| 318k| return; 110| 318k| } 111| 318k| } 112| | 113| 318k| if (state.notify()) { 114| 318k| return; 115| 318k| } 116| | 117| 318k| if (not state.has_body()) { 118| 318k| write_response(obj, state); 119| 318k| } 120| 318k| else { 121| 318k| write_response(state); 122| 318k| } 123| 318k| }; 124| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE24register_object_endpointIN9repe_fuzz6nestedENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNSt3__117basic_string_viewIcNS8_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESJ_: 106| 13.1k| reg.endpoints[path] = [&obj](repe::state_view& state) mutable { 107| 13.1k| if (state.has_body()) { ------------------ | Branch (107:17): [True: 13.0k, False: 79] ------------------ 108| 13.0k| if (!read_params(obj, state)) { ------------------ | Branch (108:20): [True: 12.8k, False: 182] ------------------ 109| 12.8k| return; 110| 12.8k| } 111| 13.0k| } 112| | 113| 261| if (state.notify()) { ------------------ | Branch (113:17): [True: 47, False: 214] ------------------ 114| 47| return; 115| 47| } 116| | 117| 214| if (not state.has_body()) { ------------------ | Branch (117:17): [True: 44, False: 170] ------------------ 118| 44| write_response(obj, state); 119| 44| } 120| 170| else { 121| 170| write_response(state); 122| 170| } 123| 214| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 151| 318k| { 152| 318k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 318k| if (state.has_body()) { 154| 318k| if (!read_params(var, state)) { 155| 318k| return; 156| 318k| } 157| 318k| } 158| | 159| 318k| if (state.notify()) { 160| 318k| return; 161| 318k| } 162| | 163| 318k| if (not state.has_body()) { 164| 318k| write_response(var, state); 165| 318k| } 166| 318k| else { 167| 318k| write_response(state); 168| 318k| } 169| 318k| }; 170| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__16vectorIiNS4_9allocatorIiEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESL_: 152| 13.1k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 13.1k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 13.0k, False: 79] ------------------ 154| 13.0k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 13.0k, False: 72] ------------------ 155| 13.0k| return; 156| 13.0k| } 157| 13.0k| } 158| | 159| 151| if (state.notify()) { ------------------ | Branch (159:17): [True: 40, False: 111] ------------------ 160| 40| return; 161| 40| } 162| | 163| 111| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 44, False: 67] ------------------ 164| 44| write_response(var, state); 165| 44| } 166| 67| else { 167| 67| write_response(state); 168| 67| } 169| 111| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 151| 318k| { 152| 318k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 318k| if (state.has_body()) { 154| 318k| if (!read_params(var, state)) { 155| 318k| return; 156| 318k| } 157| 318k| } 158| | 159| 318k| if (state.notify()) { 160| 318k| return; 161| 318k| } 162| | 163| 318k| if (not state.has_body()) { 164| 318k| write_response(var, state); 165| 318k| } 166| 318k| else { 167| 318k| write_response(state); 168| 318k| } 169| 318k| }; 170| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEiNS4_4lessISB_EENS9_INS4_4pairIKSB_iEEEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlRNS_4repe10state_viewEE_clEST_: 152| 13.2k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 13.2k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 13.1k, False: 79] ------------------ 154| 13.1k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 13.1k, False: 40] ------------------ 155| 13.1k| return; 156| 13.1k| } 157| 13.1k| } 158| | 159| 119| if (state.notify()) { ------------------ | Branch (159:17): [True: 43, False: 76] ------------------ 160| 43| return; 161| 43| } 162| | 163| 76| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 44, False: 32] ------------------ 164| 44| write_response(var, state); 165| 44| } 166| 32| else { 167| 32| write_response(state); 168| 32| } 169| 76| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_: 151| 318k| { 152| 318k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 318k| if (state.has_body()) { 154| 318k| if (!read_params(var, state)) { 155| 318k| return; 156| 318k| } 157| 318k| } 158| | 159| 318k| if (state.notify()) { 160| 318k| return; 161| 318k| } 162| | 163| 318k| if (not state.has_body()) { 164| 318k| write_response(var, state); 165| 318k| } 166| 318k| else { 167| 318k| write_response(state); 168| 318k| } 169| 318k| }; 170| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__18optionalIdEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT0_ENUlRNS_4repe10state_viewEE_clESJ_: 152| 13.1k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 13.1k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 13.0k, False: 79] ------------------ 154| 13.0k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 11.5k, False: 1.48k] ------------------ 155| 11.5k| return; 156| 11.5k| } 157| 13.0k| } 158| | 159| 1.56k| if (state.notify()) { ------------------ | Branch (159:17): [True: 533, False: 1.03k] ------------------ 160| 533| return; 161| 533| } 162| | 163| 1.03k| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 44, False: 986] ------------------ 164| 44| write_response(var, state); 165| 44| } 166| 986| else { 167| 986| write_response(state); 168| 986| } 169| 1.03k| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_: 151| 318k| { 152| 318k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 318k| if (state.has_body()) { 154| 318k| if (!read_params(var, state)) { 155| 318k| return; 156| 318k| } 157| 318k| } 158| | 159| 318k| if (state.notify()) { 160| 318k| return; 161| 318k| } 162| | 163| 318k| if (not state.has_body()) { 164| 318k| write_response(var, state); 165| 318k| } 166| 318k| else { 167| 318k| write_response(state); 168| 318k| } 169| 318k| }; 170| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_variable_endpointINSt3__17variantIJNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT0_ENUlRNS_4repe10state_viewEE_clESP_: 152| 13.1k| reg.endpoints[path] = [&var](repe::state_view& state) mutable { 153| 13.1k| if (state.has_body()) { ------------------ | Branch (153:17): [True: 13.0k, False: 78] ------------------ 154| 13.0k| if (!read_params(var, state)) { ------------------ | Branch (154:20): [True: 12.6k, False: 463] ------------------ 155| 12.6k| return; 156| 12.6k| } 157| 13.0k| } 158| | 159| 541| if (state.notify()) { ------------------ | Branch (159:17): [True: 208, False: 333] ------------------ 160| 208| return; 161| 208| } 162| | 163| 333| if (not state.has_body()) { ------------------ | Branch (163:17): [True: 44, False: 289] ------------------ 164| 44| write_response(var, state); 165| 44| } 166| 289| else { 167| 289| write_response(state); 168| 289| } 169| 333| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 73| 318k| { 74| 318k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 318k| static thread_local std::decay_t params{}; 76| 318k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 318k| if (!read_params(params, state)) { 78| 318k| return; 79| 318k| } 80| | 81| 318k| using Result = std::invoke_result_t; 82| | 83| 318k| if (state.notify()) { 84| 318k| if constexpr (std::same_as) { 85| 318k| func(params); 86| 318k| } 87| 318k| else { 88| 318k| std::ignore = func(params); 89| 318k| } 90| 318k| return; 91| 318k| } 92| 318k| if constexpr (std::same_as) { 93| 318k| func(params); 94| 318k| write_response(state); 95| 318k| } 96| 318k| else { 97| 318k| auto ret = func(params); 98| 318k| write_response(ret, state); 99| 318k| } 100| 318k| }; 101| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFiiEEEiNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlRNS_4repe10state_viewEE_clESL_: 74| 13.1k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 13.1k| static thread_local std::decay_t params{}; 76| 13.1k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 13.1k| if (!read_params(params, state)) { ------------------ | Branch (77:17): [True: 12.7k, False: 378] ------------------ 78| 12.7k| return; 79| 12.7k| } 80| | 81| 378| using Result = std::invoke_result_t; 82| | 83| 378| if (state.notify()) { ------------------ | Branch (83:17): [True: 65, False: 313] ------------------ 84| | if constexpr (std::same_as) { 85| | func(params); 86| | } 87| 65| else { 88| 65| std::ignore = func(params); 89| 65| } 90| 65| return; 91| 65| } 92| | if constexpr (std::same_as) { 93| | func(params); 94| | write_response(state); 95| | } 96| 313| else { 97| 313| auto ret = func(params); 98| 313| write_response(ret, state); 99| 313| } 100| 313| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_: 73| 318k| { 74| 318k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 318k| static thread_local std::decay_t params{}; 76| 318k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 318k| if (!read_params(params, state)) { 78| 318k| return; 79| 318k| } 80| | 81| 318k| using Result = std::invoke_result_t; 82| | 83| 318k| if (state.notify()) { 84| 318k| if constexpr (std::same_as) { 85| 318k| func(params); 86| 318k| } 87| 318k| else { 88| 318k| std::ignore = func(params); 89| 318k| } 90| 318k| return; 91| 318k| } 92| 318k| if constexpr (std::same_as) { 93| 318k| func(params); 94| 318k| write_response(state); 95| 318k| } 96| 318k| else { 97| 318k| auto ret = func(params); 98| 318k| write_response(ret, state); 99| 318k| } 100| 318k| }; 101| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFNS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSB_EEESD_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcS8_EERT_RT1_ENUlRNS_4repe10state_viewEE_clESR_: 74| 13.1k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 13.1k| static thread_local std::decay_t params{}; 76| 13.1k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 13.1k| if (!read_params(params, state)) { ------------------ | Branch (77:17): [True: 12.6k, False: 445] ------------------ 78| 12.6k| return; 79| 12.6k| } 80| | 81| 445| using Result = std::invoke_result_t; 82| | 83| 445| if (state.notify()) { ------------------ | Branch (83:17): [True: 165, False: 280] ------------------ 84| | if constexpr (std::same_as) { 85| | func(params); 86| | } 87| 165| else { 88| 165| std::ignore = func(params); 89| 165| } 90| 165| return; 91| 165| } 92| | if constexpr (std::same_as) { 93| | func(params); 94| | write_response(state); 95| | } 96| 280| else { 97| 280| auto ret = func(params); 98| 280| write_response(ret, state); 99| 280| } 100| 280| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFN9repe_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 73| 318k| { 74| 318k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 318k| static thread_local std::decay_t params{}; 76| 318k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 318k| if (!read_params(params, state)) { 78| 318k| return; 79| 318k| } 80| | 81| 318k| using Result = std::invoke_result_t; 82| | 83| 318k| if (state.notify()) { 84| 318k| if constexpr (std::same_as) { 85| 318k| func(params); 86| 318k| } 87| 318k| else { 88| 318k| std::ignore = func(params); 89| 318k| } 90| 318k| return; 91| 318k| } 92| 318k| if constexpr (std::same_as) { 93| 318k| func(params); 94| 318k| write_response(state); 95| 318k| } 96| 318k| else { 97| 318k| auto ret = func(params); 98| 318k| write_response(ret, state); 99| 318k| } 100| 318k| }; 101| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFN9repe_fuzz5pointERKS7_EEES9_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlRNS_4repe10state_viewEE_clESP_: 74| 13.1k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 13.1k| static thread_local std::decay_t params{}; 76| 13.1k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 13.1k| if (!read_params(params, state)) { ------------------ | Branch (77:17): [True: 13.0k, False: 78] ------------------ 78| 13.0k| return; 79| 13.0k| } 80| | 81| 78| using Result = std::invoke_result_t; 82| | 83| 78| if (state.notify()) { ------------------ | Branch (83:17): [True: 9, False: 69] ------------------ 84| | if constexpr (std::same_as) { 85| | func(params); 86| | } 87| 9| else { 88| 9| std::ignore = func(params); 89| 9| } 90| 9| return; 91| 9| } 92| | if constexpr (std::same_as) { 93| | func(params); 94| | write_response(state); 95| | } 96| 69| else { 97| 69| auto ret = func(params); 98| 69| write_response(ret, state); 99| 69| } 100| 69| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 73| 318k| { 74| 318k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 318k| static thread_local std::decay_t params{}; 76| 318k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 318k| if (!read_params(params, state)) { 78| 318k| return; 79| 318k| } 80| | 81| 318k| using Result = std::invoke_result_t; 82| | 83| 318k| if (state.notify()) { 84| 318k| if constexpr (std::same_as) { 85| 318k| func(params); 86| 318k| } 87| 318k| else { 88| 318k| std::ignore = func(params); 89| 318k| } 90| 318k| return; 91| 318k| } 92| 318k| if constexpr (std::same_as) { 93| 318k| func(params); 94| 318k| write_response(state); 95| 318k| } 96| 318k| else { 97| 318k| auto ret = func(params); 98| 318k| write_response(ret, state); 99| 318k| } 100| 318k| }; 101| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE32register_param_function_endpointIRNSt3__18functionIFdRNS4_6vectorIdNS4_9allocatorIdEEEEEEESA_NS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlRNS_4repe10state_viewEE_clESQ_: 74| 13.1k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 75| 13.1k| static thread_local std::decay_t params{}; 76| 13.1k| params = {}; // reset to avoid stale optional/variant fields across calls 77| 13.1k| if (!read_params(params, state)) { ------------------ | Branch (77:17): [True: 12.7k, False: 408] ------------------ 78| 12.7k| return; 79| 12.7k| } 80| | 81| 408| using Result = std::invoke_result_t; 82| | 83| 408| if (state.notify()) { ------------------ | Branch (83:17): [True: 8, False: 400] ------------------ 84| | if constexpr (std::same_as) { 85| | func(params); 86| | } 87| 8| else { 88| 8| std::ignore = func(params); 89| 8| } 90| 8| return; 91| 8| } 92| | if constexpr (std::same_as) { 93| | func(params); 94| | write_response(state); 95| | } 96| 400| else { 97| 400| auto ret = func(params); 98| 400| write_response(ret, state); 99| 400| } 100| 400| }; _ZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_: 50| 318k| { 51| 318k| if constexpr (std::same_as) { 52| 318k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 53| 318k| func(); 54| 318k| if (state.notify()) { 55| 318k| return; 56| 318k| } 57| 318k| write_response(state); 58| 318k| }; 59| | } 60| | else { 61| | reg.endpoints[path] = [&func](repe::state_view& state) mutable { 62| | if (state.notify()) { 63| | std::ignore = func(); 64| | return; 65| | } 66| | write_response(func(), state); 67| | }; 68| | } 69| 318k| } _ZZN3glz13registry_implIXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEELj30000EE26register_function_endpointIRNSt3__18functionIFvvEEEvNS_8registryIXtlS1_Lj10ELb1ELb0ELb1ELb1EEELj30000EEEEEvNS4_17basic_string_viewIcNS4_11char_traitsIcEEEERT_RT1_ENUlRNS_4repe10state_viewEE_clESL_: 52| 13.1k| reg.endpoints[path] = [&func](repe::state_view& state) mutable { 53| 13.1k| func(); 54| 13.1k| if (state.notify()) { ------------------ | Branch (54:20): [True: 5.16k, False: 7.96k] ------------------ 55| 5.16k| return; 56| 5.16k| } 57| 7.96k| write_response(state); 58| 7.96k| }; _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS9_S9_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 17| 247| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 247| if (n > 15) { ------------------ | Branch (19:11): [True: 146, False: 101] ------------------ 20| 146| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 146| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 146| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 146| const __m128i zero = _mm_setzero_si128(); 24| | 25| 358k| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 357k, False: 146] ------------------ 26| 357k| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 357k| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 357k| const uint32_t mask = static_cast( 30| 357k| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 357k| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 357k| if (mask == 0) { ------------------ | Branch (33:17): [True: 314k, False: 43.2k] ------------------ 34| 314k| data += 16; 35| 314k| c += 16; 36| 314k| continue; 37| 314k| } 38| | 39| 43.2k| const uint32_t length = countr_zero(mask); 40| 43.2k| c += length; 41| 43.2k| data += length; 42| 43.2k| write_escape(); 43| 43.2k| } 44| 146| } 45| 247| } _ZN3glz6detail18sse2_string_escapeIcRZNS_2toILj10ENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS9_SD_TkNS_10is_contextERNS_7contextEmEEvOT1_OT2_OT0_RT3_EUlvE0_EEvRPKcSR_RPT_mSL_: 17| 596| { 18| | // SSE2: 16 bytes at a time with direct comparison instructions 19| 596| if (n > 15) { ------------------ | Branch (19:11): [True: 143, False: 453] ------------------ 20| 143| const __m128i quote_vec = _mm_set1_epi8('"'); 21| 143| const __m128i bs_vec = _mm_set1_epi8('\\'); 22| 143| const __m128i ctrl_mask = _mm_set1_epi8(static_cast(0xE0)); 23| 143| const __m128i zero = _mm_setzero_si128(); 24| | 25| 724k| for (const char* end_m15 = e - 15; c < end_m15;) { ------------------ | Branch (25:45): [True: 724k, False: 143] ------------------ 26| 724k| __m128i v = _mm_loadu_si128(reinterpret_cast(c)); 27| 724k| _mm_storeu_si128(reinterpret_cast<__m128i*>(data), v); 28| | 29| 724k| const uint32_t mask = static_cast( 30| 724k| _mm_movemask_epi8(_mm_or_si128(_mm_or_si128(_mm_cmpeq_epi8(v, quote_vec), _mm_cmpeq_epi8(v, bs_vec)), 31| 724k| _mm_cmpeq_epi8(_mm_and_si128(v, ctrl_mask), zero)))); 32| | 33| 724k| if (mask == 0) { ------------------ | Branch (33:17): [True: 719k, False: 4.90k] ------------------ 34| 719k| data += 16; 35| 719k| c += 16; 36| 719k| continue; 37| 719k| } 38| | 39| 4.90k| const uint32_t length = countr_zero(mask); 40| 4.90k| c += length; 41| 4.90k| data += length; 42| 4.90k| write_escape(); 43| 4.90k| } 44| 143| } 45| 596| } _ZN3glz3getILm0ETkNS_6tuplet9indexableERKNS_5tupleIJMN9repe_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EMS4_FNSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEERKNS3_6nestedEEEEEEEDcOT0_: 432| 304k| { 433| 304k| return static_cast(tup)[tuplet::tag()]; 434| 304k| } _ZNKR3glz6tuplet10tuple_elemILm0EMN9repe_fuzz10member_apiEiEixENSt3__117integral_constantImLm0EEE: 112| 304k| constexpr decltype(auto) operator[](tag) const& { return (value); } _ZN3glz3getILm1ETkNS_6tuplet9indexableERKNS_5tupleIJMN9repe_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EMS4_FNSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEERKNS3_6nestedEEEEEEEDcOT0_: 432| 304k| { 433| 304k| return static_cast(tup)[tuplet::tag()]; 434| 304k| } _ZNKR3glz6tuplet10tuple_elemILm1EMN9repe_fuzz10member_apiEFiiEEixENSt3__117integral_constantImLm1EEE: 112| 304k| constexpr decltype(auto) operator[](tag) const& { return (value); } _ZN3glz3getILm2ETkNS_6tuplet9indexableERKNS_5tupleIJMN9repe_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EMS4_FNSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEERKNS3_6nestedEEEEEEEDcOT0_: 432| 304k| { 433| 304k| return static_cast(tup)[tuplet::tag()]; 434| 304k| } _ZNKR3glz6tuplet10tuple_elemILm2EMN9repe_fuzz10member_apiEFvvEEixENSt3__117integral_constantImLm2EEE: 112| 304k| constexpr decltype(auto) operator[](tag) const& { return (value); } _ZN3glz3getILm3ETkNS_6tuplet9indexableERKNS_5tupleIJMN9repe_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EMS4_FNSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEERKNS3_6nestedEEEEEEEDcOT0_: 432| 304k| { 433| 304k| return static_cast(tup)[tuplet::tag()]; 434| 304k| } _ZNKR3glz6tuplet10tuple_elemILm3EMN9repe_fuzz10member_apiEFNS2_5pointERKS4_EEixENSt3__117integral_constantImLm3EEE: 112| 304k| constexpr decltype(auto) operator[](tag) const& { return (value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 432| 28.1k| { 433| 28.1k| return static_cast(tup)[tuplet::tag()]; 434| 28.1k| } _ZNO3glz6tuplet10tuple_elemILm0ERdEixENSt3__117integral_constantImLm0EEE: 113| 47.6k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3tieIJddEEENS_5tupleIJDpRT_EEES4_: 442| 362k| { 443| 362k| return {t...}; 444| 362k| } _ZN3glz3getILm1ETkNS_6tuplet9indexableENS_5tupleIJRdS3_EEEEEDcOT0_: 432| 15.5k| { 433| 15.5k| return static_cast(tup)[tuplet::tag()]; 434| 15.5k| } _ZNO3glz6tuplet10tuple_elemILm1ERdEixENSt3__117integral_constantImLm1EEE: 113| 15.5k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm0ERdEixENSt3__117integral_constantImLm0EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm1ETkNS_6tuplet9indexableERNS_5tupleIJRdS3_EEEEEDcOT0_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm1ERdEixENSt3__117integral_constantImLm1EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm4ETkNS_6tuplet9indexableERKNS_5tupleIJMN9repe_fuzz10member_apiEiMS4_FiiEMS4_FvvEMS4_FNS3_5pointERKSA_EMS4_FNSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEERKNS3_6nestedEEEEEEEDcOT0_: 432| 304k| { 433| 304k| return static_cast(tup)[tuplet::tag()]; 434| 304k| } _ZNKR3glz6tuplet10tuple_elemILm4EMN9repe_fuzz10member_apiEFNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKNS2_6nestedEEEixENS4_17integral_constantImLm4EEE: 112| 304k| constexpr decltype(auto) operator[](tag) const& { return (value); } _ZNO3glz6tuplet10tuple_elemILm0ERiEixENSt3__117integral_constantImLm0EEE: 113| 38.2k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_5tupleIJDpRT_EEESB_: 442| 326k| { 443| 326k| return {t...}; 444| 326k| } _ZN3glz3getILm1ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 432| 7.85k| { 433| 7.85k| return static_cast(tup)[tuplet::tag()]; 434| 7.85k| } _ZNO3glz6tuplet10tuple_elemILm1ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEixENS2_17integral_constantImLm1EEE: 113| 7.87k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 38.2k| { 433| 38.2k| return static_cast(tup)[tuplet::tag()]; 434| 38.2k| } _ZN3glz3tieIJiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEN9repe_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_: 442| 380k| { 443| 380k| return {t...}; 444| 380k| } _ZN3glz3getILm1ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 19| { 433| 19| return static_cast(tup)[tuplet::tag()]; 434| 19| } _ZN3glz3getILm2ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 897| { 433| 897| return static_cast(tup)[tuplet::tag()]; 434| 897| } _ZNO3glz6tuplet10tuple_elemILm2ERN9repe_fuzz5pointEEixENSt3__117integral_constantImLm2EEE: 113| 897| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm3ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 729| { 433| 729| return static_cast(tup)[tuplet::tag()]; 434| 729| } _ZNO3glz6tuplet10tuple_elemILm3ERN9repe_fuzz6nestedEEixENSt3__117integral_constantImLm3EEE: 113| 729| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm4ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 9.31k| { 433| 9.31k| return static_cast(tup)[tuplet::tag()]; 434| 9.31k| } _ZNO3glz6tuplet10tuple_elemILm4ERNSt3__16vectorIiNS2_9allocatorIiEEEEEixENS2_17integral_constantImLm4EEE: 113| 9.31k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm5ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 1.38k| { 433| 1.38k| return static_cast(tup)[tuplet::tag()]; 434| 1.38k| } _ZNO3glz6tuplet10tuple_elemILm5ERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEEEixENS2_17integral_constantImLm5EEE: 113| 1.38k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm6ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 2.36k| { 433| 2.36k| return static_cast(tup)[tuplet::tag()]; 434| 2.36k| } _ZNO3glz6tuplet10tuple_elemILm6ERNSt3__18optionalIdEEEixENS2_17integral_constantImLm6EEE: 113| 2.36k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableENS_5tupleIJRdEEEEEDcOT0_: 432| 19.5k| { 433| 19.5k| return static_cast(tup)[tuplet::tag()]; 434| 19.5k| } _ZN3glz3tieIJdEEENS_5tupleIJDpRT_EEES4_: 442| 19.5k| { 443| 19.5k| return {t...}; 444| 19.5k| } _ZN3glz3getILm7ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 8.89k| { 433| 8.89k| return static_cast(tup)[tuplet::tag()]; 434| 8.89k| } _ZNO3glz6tuplet10tuple_elemILm7ERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9repe_fuzz6amountEEEEEixENS2_17integral_constantImLm7EEE: 113| 8.89k| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm8ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 106| { 433| 106| return static_cast(tup)[tuplet::tag()]; 434| 106| } _ZNO3glz6tuplet10tuple_elemILm8ERNSt3__18functionIFiiEEEEixENS2_17integral_constantImLm8EEE: 113| 106| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm9ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 80| { 433| 80| return static_cast(tup)[tuplet::tag()]; 434| 80| } _ZNO3glz6tuplet10tuple_elemILm9ERNSt3__18functionIFNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS9_EEEEixENS2_17integral_constantImLm9EEE: 113| 80| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm10ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 264| { 433| 264| return static_cast(tup)[tuplet::tag()]; 434| 264| } _ZNO3glz6tuplet10tuple_elemILm10ERNSt3__18functionIFN9repe_fuzz5pointERKS5_EEEEixENS2_17integral_constantImLm10EEE: 113| 264| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm11ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 54| { 433| 54| return static_cast(tup)[tuplet::tag()]; 434| 54| } _ZNO3glz6tuplet10tuple_elemILm11ERNSt3__18functionIFdRNS2_6vectorIdNS2_9allocatorIdEEEEEEEEixENS2_17integral_constantImLm11EEE: 113| 54| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm12ETkNS_6tuplet9indexableENS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 56| { 433| 56| return static_cast(tup)[tuplet::tag()]; 434| 56| } _ZNO3glz6tuplet10tuple_elemILm12ERNSt3__18functionIFvvEEEEixENS2_17integral_constantImLm12EEE: 113| 56| constexpr decltype(auto) operator[](tag) && { return (std::move(*this).value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm0ERiEixENSt3__117integral_constantImLm0EEE: 111| 636k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm1ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm1ERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEixENS2_17integral_constantImLm1EEE: 111| 636k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm2ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm2ERN9repe_fuzz5pointEEixENSt3__117integral_constantImLm2EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm0ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZN3glz3getILm1ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEEEDcOT0_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZN3glz3getILm3ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm3ERN9repe_fuzz6nestedEEixENSt3__117integral_constantImLm3EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm4ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm4ERNSt3__16vectorIiNS2_9allocatorIiEEEEEixENS2_17integral_constantImLm4EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm5ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm5ERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEiNS2_4lessIS9_EENS7_INS2_4pairIKS9_iEEEEEEEixENS2_17integral_constantImLm5EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm6ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm6ERNSt3__18optionalIdEEEixENS2_17integral_constantImLm6EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm7ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm7ERNSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9repe_fuzz6amountEEEEEixENS2_17integral_constantImLm7EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm8ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm8ERNSt3__18functionIFiiEEEEixENS2_17integral_constantImLm8EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm9ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm9ERNSt3__18functionIFNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS9_EEEEixENS2_17integral_constantImLm9EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm10ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm10ERNSt3__18functionIFN9repe_fuzz5pointERKS5_EEEEixENS2_17integral_constantImLm10EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm11ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm11ERNSt3__18functionIFdRNS2_6vectorIdNS2_9allocatorIdEEEEEEEEixENS2_17integral_constantImLm11EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz3getILm12ETkNS_6tuplet9indexableERNS_5tupleIJRiRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERN9repe_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_: 432| 318k| { 433| 318k| return static_cast(tup)[tuplet::tag()]; 434| 318k| } _ZNR3glz6tuplet10tuple_elemILm12ERNSt3__18functionIFvvEEEEixENS2_17integral_constantImLm12EEE: 111| 318k| constexpr decltype(auto) operator[](tag) & { return (value); } _ZN3glz4atoiITkNSt3__18integralEicEEbRT_RPKT0_S6_: 803| 585k| { 804| | // The number of characters needed at most for each type, rounded to nearest 8 bytes 805| 585k| constexpr auto buffer_length = int_buffer_lengths[std::bit_width(sizeof(T)) - 1]; 806| | // We copy the rest of the buffer, or buffer_length bytes, into a null terminated buffer. The 807| | // trailing byte is never written by the copy, so the null-terminated atoi below always halts 808| | // inside the array even when the input fills it: the exponent scan stops at a non-digit rather 809| | // than after a fixed digit count, and a value-initialized array alone would not terminate a 810| | // copy that covers every byte. 811| 585k| std::array data{}; 812| 585k| const auto n = size_t(end - it); 813| 585k| if (n > 0) [[likely]] { ------------------ | Branch (813:11): [True: 585k, False: 0] ------------------ 814| 585k| const auto truncated = n > buffer_length; 815| 585k| std::memcpy(data.data(), it, truncated ? buffer_length : n); ------------------ | Branch (815:39): [True: 544k, False: 41.2k] ------------------ 816| | 817| 585k| const auto start = data.data(); 818| 585k| const auto* c = start; 819| 585k| const auto valid = glz::atoi(v, c); 820| 585k| const auto consumed = size_t(c - start); 821| 585k| it += consumed; 822| | // Reaching the end of a truncated copy means the number was cut off: parsing halted on the 823| | // terminator this buffer supplies rather than on a character of the input, so what parsed is 824| | // a prefix and its value is not the number's. Only zero padding can stretch a number this 825| | // far -- no in-range integer needs buffer_length characters -- but a caller that ignores 826| | // trailing content would otherwise take the prefix's value as the answer. 827| 585k| return valid && not(truncated && consumed == buffer_length); ------------------ | Branch (827:17): [True: 525k, False: 59.9k] | Branch (827:30): [True: 514k, False: 11.0k] | Branch (827:43): [True: 8, False: 514k] ------------------ 828| 585k| } 829| 0| else [[unlikely]] { 830| 0| return false; 831| 0| } 832| 585k| } _ZN3glz4atoiITkNSt3__18integralEiKcQsr3stdE11is_signed_vIT_EEEbRS3_RPT0_: 715| 585k| { 716| 585k| using X = std::decay_t; 717| 585k| using utype = std::make_unsigned_t; 718| | 719| 585k| const uint8_t sign = *c == '-'; 720| 585k| if (auto ptr = parse_int(v, reinterpret_cast(c))) [[likely]] { ------------------ | Branch (720:16): [True: 530k, False: 55.4k] ------------------ 721| 530k| c = reinterpret_cast(ptr); 722| 530k| if (*c == 'e' || *c == 'E') { ------------------ | Branch (722:14): [True: 18.6k, False: 511k] | Branch (722:27): [True: 42.8k, False: 468k] ------------------ 723| 61.4k| ++c; 724| 61.4k| } 725| 468k| else { 726| 468k| if (*c == '.') [[unlikely]] { ------------------ | Branch (726:17): [True: 1.44k, False: 467k] ------------------ 727| 1.44k| return false; 728| 1.44k| } 729| 467k| return true; 730| 468k| } 731| | 732| 61.4k| c += (*c == '+'); 733| | 734| 61.4k| if (not is_digit(*c)) [[unlikely]] { ------------------ | Branch (734:14): [True: 960, False: 60.4k] ------------------ 735| 960| return false; 736| 960| } 737| 60.4k| const uint32_t exp = parse_exponent(c); 738| | // As in the unsigned overload: only a non-zero magnitude can overflow, so "0e19" and 739| | // "-0e19" are in range for every width. `v` is already the signed mantissa, and negative 740| | // zero compares equal to zero, so both spellings land here with the value they should keep. 741| | if constexpr (sizeof(T) == 1) { 742| | if (exp > 2) [[unlikely]] { 743| | return v == 0; 744| | } 745| | } 746| | else if constexpr (sizeof(T) == 2) { 747| | if (exp > 4) [[unlikely]] { 748| | return v == 0; 749| | } 750| | } 751| 60.4k| else if constexpr (sizeof(T) == 4) { 752| 60.4k| if (exp > 9) [[unlikely]] { ------------------ | Branch (752:17): [True: 4.59k, False: 55.8k] ------------------ 753| 4.59k| return v == 0; 754| 4.59k| } 755| | } 756| | else { 757| | if (exp > 18) [[unlikely]] { 758| | return v == 0; 759| | } 760| | } 761| | 762| 55.8k| utype i = utype((utype(v) ^ -sign) + sign); 763| 60.4k| if constexpr (sizeof(T) < 8) { 764| | // Scale in a width the product cannot wrap, then range check before narrowing. Scaling 765| | // inside `utype` truncated first and checked afterwards, so an out-of-range magnitude 766| | // aliased onto an accepted one: "13e2" read as 20 for int8_t and "5e9" as 705032704 for 767| | // int32_t. The widest case here is a 4-byte magnitude scaled by 10^9, which stays well 768| | // inside uint64_t. The unsigned path already widens the same way. 769| 60.4k| const uint64_t scaled = uint64_t(i) * powers_of_ten_int[exp]; 770| 60.4k| v = T((utype(scaled) ^ -sign) + sign); 771| | // Bound the magnitude directly rather than subtracting the sign from it: a negative 772| | // zero makes `scaled - sign` underflow, and the old narrow expression only survived 773| | // that because it promoted to int. A negative value may reach one past the positive 774| | // limit, which is exactly INT_MIN's magnitude. 775| 60.4k| return scaled <= uint64_t((std::numeric_limits::max)()) + sign; 776| | } 777| | else { 778| | // Scale the sign-stripped magnitude `i`, not the two's-complement bit pattern of `v`: 779| | // for a negative value that pattern is a huge unsigned number, so every negative 780| | // 64-bit integer written with an exponent ("-1e2") overflowed and was rejected. The 781| | // narrower branches above already scale `i`. 782| |#if defined(__SIZEOF_INT128__) 783| | const __uint128_t res = __uint128_t(i) * powers_of_ten_int[exp]; 784| | v = T((uint64_t(res) ^ -sign) + sign); 785| | // Compare the full 128-bit product. Narrowing it to 64 bits first would let an 786| | // out-of-range magnitude alias onto an accepted one, e.g. 9e36 truncating into range. 787| | return res <= __uint128_t(9223372036854775807ull + sign); 788| |#else 789| | const auto res = full_multiplication(i, powers_of_ten_int[exp]); 790| | v = T((uint64_t(res.low) ^ -sign) + sign); 791| | return res.high == 0 && (uint64_t(res.low) <= (9223372036854775807ull + sign)); 792| |#endif 793| | } 794| 60.4k| } 795| 115k| return false; 796| 585k| } _ZN3glz9parse_intITkNSt3__18integralEiQaasr3stdE11is_signed_vIT_ElestS2_Li8EEEPKhRS2_S4_: 476| 585k| { 477| 585k| const uint8_t sign = *c == '-'; 478| 585k| c += sign; 479| | 480| 585k| if (is_digit(*c)) [[likely]] { ------------------ | Branch (480:11): [True: 533k, False: 51.5k] ------------------ 481| 533k| v = *c - '0'; 482| 533k| ++c; 483| 533k| } 484| 51.5k| else [[unlikely]] { 485| 51.5k| return {}; 486| 51.5k| } 487| | 488| 533k| if (is_digit(*c)) { ------------------ | Branch (488:11): [True: 415k, False: 118k] ------------------ 489| 415k| v = v * 10 + (*c - '0'); 490| 415k| ++c; 491| 415k| } 492| 118k| else { 493| 118k| if (sign) { ------------------ | Branch (493:14): [True: 7.06k, False: 111k] ------------------ 494| 7.06k| v = -v; 495| 7.06k| } 496| 118k| return c; 497| 118k| } 498| | 499| 415k| if (c[-2] == '0') [[unlikely]] { ------------------ | Branch (499:11): [True: 91, False: 415k] ------------------ 500| 91| return {}; 501| 91| } 502| | 503| 415k| if constexpr (sizeof(T) > 1) { 504| 415k| if (is_digit(*c)) { ------------------ | Branch (504:14): [True: 282k, False: 132k] ------------------ 505| 282k| v = v * 10 + (*c - '0'); 506| 282k| ++c; 507| 282k| } 508| 132k| else { 509| 132k| if (sign) { ------------------ | Branch (509:17): [True: 19.1k, False: 113k] ------------------ 510| 19.1k| v = -v; 511| 19.1k| } 512| 132k| return c; 513| 132k| } 514| | 515| 282k| if (is_digit(*c)) { ------------------ | Branch (515:14): [True: 240k, False: 42.5k] ------------------ 516| 240k| v = v * 10 + (*c - '0'); 517| 240k| ++c; 518| 240k| } 519| 42.5k| else { 520| 42.5k| if (sign) { ------------------ | Branch (520:17): [True: 5.03k, False: 37.5k] ------------------ 521| 5.03k| v = -v; 522| 5.03k| } 523| 42.5k| return c; 524| 42.5k| } 525| | 526| 240k| if constexpr (sizeof(T) > 2) { 527| 240k| if (is_digit(*c)) { ------------------ | Branch (527:17): [True: 202k, False: 37.8k] ------------------ 528| 202k| v = v * 10 + (*c - '0'); 529| 202k| ++c; 530| 202k| } 531| 37.8k| else { 532| 37.8k| if (sign) { ------------------ | Branch (532:20): [True: 10.6k, False: 27.2k] ------------------ 533| 10.6k| v = -v; 534| 10.6k| } 535| 37.8k| return c; 536| 37.8k| } 537| | 538| 202k| if (is_digit(*c)) { ------------------ | Branch (538:17): [True: 165k, False: 37.1k] ------------------ 539| 165k| v = v * 10 + (*c - '0'); 540| 165k| ++c; 541| 165k| } 542| 37.1k| else { 543| 37.1k| if (sign) { ------------------ | Branch (543:20): [True: 8.13k, False: 29.0k] ------------------ 544| 8.13k| v = -v; 545| 8.13k| } 546| 37.1k| return c; 547| 37.1k| } 548| | 549| 165k| if (is_digit(*c)) { ------------------ | Branch (549:17): [True: 116k, False: 48.8k] ------------------ 550| 116k| v = v * 10 + (*c - '0'); 551| 116k| ++c; 552| 116k| } 553| 48.8k| else { 554| 48.8k| if (sign) { ------------------ | Branch (554:20): [True: 12.9k, False: 35.8k] ------------------ 555| 12.9k| v = -v; 556| 12.9k| } 557| 48.8k| return c; 558| 48.8k| } 559| | 560| 116k| if (is_digit(*c)) { ------------------ | Branch (560:17): [True: 59.1k, False: 57.3k] ------------------ 561| 59.1k| v = v * 10 + (*c - '0'); 562| 59.1k| ++c; 563| 59.1k| } 564| 57.3k| else { 565| 57.3k| if (sign) { ------------------ | Branch (565:20): [True: 15.1k, False: 42.1k] ------------------ 566| 15.1k| v = -v; 567| 15.1k| } 568| 57.3k| return c; 569| 57.3k| } 570| | 571| 59.1k| if (is_digit(*c)) { ------------------ | Branch (571:17): [True: 46.7k, False: 12.4k] ------------------ 572| 46.7k| v = v * 10 + (*c - '0'); 573| 46.7k| ++c; 574| 46.7k| } 575| 12.4k| else { 576| 12.4k| if (sign) { ------------------ | Branch (576:20): [True: 3.75k, False: 8.65k] ------------------ 577| 3.75k| v = -v; 578| 3.75k| } 579| 12.4k| return c; 580| 12.4k| } 581| | 582| | if constexpr (sizeof(T) > 4) { 583| | if (is_digit(*c)) { 584| | v = v * 10 + (*c - '0'); 585| | ++c; 586| | } 587| | else { 588| | if (sign) { 589| | v = -v; 590| | } 591| | return c; 592| | } 593| | 594| | if (is_digit(*c)) { 595| | v = v * 10 + (*c - '0'); 596| | ++c; 597| | } 598| | else { 599| | if (sign) { 600| | v = -v; 601| | } 602| | return c; 603| | } 604| | 605| | if (is_digit(*c)) { 606| | v = v * 10 + (*c - '0'); 607| | ++c; 608| | } 609| | else { 610| | if (sign) { 611| | v = -v; 612| | } 613| | return c; 614| | } 615| | 616| | if (is_digit(*c)) { 617| | v = v * 10 + (*c - '0'); 618| | ++c; 619| | } 620| | else { 621| | if (sign) { 622| | v = -v; 623| | } 624| | return c; 625| | } 626| | 627| | if (is_digit(*c)) { 628| | v = v * 10 + (*c - '0'); 629| | ++c; 630| | } 631| | else { 632| | if (sign) { 633| | v = -v; 634| | } 635| | return c; 636| | } 637| | 638| | if (is_digit(*c)) { 639| | v = v * 10 + (*c - '0'); 640| | ++c; 641| | } 642| | else { 643| | if (sign) { 644| | v = -v; 645| | } 646| | return c; 647| | } 648| | 649| | if (is_digit(*c)) { 650| | v = v * 10 + (*c - '0'); 651| | ++c; 652| | } 653| | else { 654| | if (sign) { 655| | v = -v; 656| | } 657| | return c; 658| | } 659| | 660| | if (is_digit(*c)) { 661| | v = v * 10 + (*c - '0'); 662| | ++c; 663| | } 664| | else { 665| | if (sign) { 666| | v = -v; 667| | } 668| | return c; 669| | } 670| | 671| | if (is_digit(*c)) { 672| | v = v * 10 + (*c - '0'); 673| | ++c; 674| | } 675| | else { 676| | if (sign) { 677| | v = -v; 678| | } 679| | return c; 680| | } 681| | } 682| 46.7k| } 683| 240k| } 684| | 685| 415k| if (is_digit(*c)) { ------------------ | Branch (685:11): [True: 11.3k, False: 404k] ------------------ 686| 11.3k| if (sign) { ------------------ | Branch (686:14): [True: 2.73k, False: 8.58k] ------------------ 687| 2.73k| if (would_overflow_negative(v, *c)) [[unlikely]] { ------------------ | Branch (687:17): [True: 275, False: 2.46k] ------------------ 688| 275| return {}; 689| 275| } 690| 2.46k| v = -1 * v; 691| 2.46k| v = v * 10 - (*c - '0'); 692| 2.46k| } 693| 8.58k| else { 694| 8.58k| if (would_overflow_positive(v, *c)) [[unlikely]] { ------------------ | Branch (694:17): [True: 2.22k, False: 6.36k] ------------------ 695| 2.22k| return {}; 696| 2.22k| } 697| 6.36k| v = v * 10 + (*c - '0'); 698| 6.36k| } 699| 8.82k| ++c; 700| 8.82k| if (is_digit(*c)) [[unlikely]] { ------------------ | Branch (700:14): [True: 1.32k, False: 7.50k] ------------------ 701| 1.32k| return {}; 702| 1.32k| } 703| 7.50k| return c; 704| 8.82k| } 705| | 706| 404k| if (sign) { ------------------ | Branch (706:11): [True: 6.08k, False: 398k] ------------------ 707| 6.08k| v = -v; 708| 6.08k| } 709| 404k| return c; 710| 415k| } _ZN3glz23would_overflow_negativeIiEEbu17__remove_volatileIT_Eh: 151| 2.73k| { 152| | // For negative: max magnitude is max + 1 (e.g., -2147483648 for int32) 153| 2.73k| using U = std::remove_volatile_t; 154| 2.73k| constexpr auto max_val = static_cast((std::numeric_limits::max)()) + 1; 155| 2.73k| constexpr auto threshold = max_val / 10; 156| 2.73k| constexpr auto last_digit = max_val % 10; 157| 2.73k| const auto uv = static_cast(v); 158| 2.73k| const auto digit = static_cast(next_digit - '0'); 159| | // When digit > last_digit, effective threshold is one less 160| 2.73k| return uv > (threshold - uint64_t(digit > last_digit)); 161| 2.73k| } _ZN3glz23would_overflow_positiveIiEEbu17__remove_volatileIT_Eh: 137| 8.58k| { 138| 8.58k| using U = std::remove_volatile_t; 139| 8.58k| constexpr auto max_val = static_cast((std::numeric_limits::max)()); 140| 8.58k| constexpr auto threshold = max_val / 10; 141| 8.58k| constexpr auto last_digit = max_val % 10; 142| 8.58k| const auto uv = static_cast(v); 143| 8.58k| const auto digit = static_cast(next_digit - '0'); 144| | // When digit > last_digit, effective threshold is one less 145| | // This is branch-free and faster than bitwise OR/AND approach 146| 8.58k| return uv > (threshold - uint64_t(digit > last_digit)); 147| 8.58k| } _ZN3glz8is_digitEh: 103| 2.81M| GLZ_ALWAYS_INLINE constexpr bool is_digit(const uint8_t c) noexcept { return c <= '9' && c >= '0'; } ------------------ | Branch (103:81): [True: 2.70M, False: 110k] | Branch (103:93): [True: 2.17M, False: 532k] ------------------ _ZN3glz14parse_exponentIKcEEjRPT_: 121| 60.4k| { 122| 60.4k| uint32_t exp = uint32_t(*c - '0'); 123| 60.4k| ++c; 124| 101k| while (is_digit(*c)) { ------------------ | Branch (124:14): [True: 40.5k, False: 60.4k] ------------------ 125| | // Written as a select rather than a branch: the clamp only ever engages on absurdly long 126| | // exponents, so a branch here would be a mispredict risk on the path that matters. 127| 40.5k| exp = exp < exponent_clamp ? exp * 10 + uint32_t(*c - '0') : exp; ------------------ | Branch (127:16): [True: 34.0k, False: 6.44k] ------------------ 128| 40.5k| ++c; 129| 40.5k| } 130| 60.4k| return exp; 131| 60.4k| } _ZN3glz11countr_zeroEm: 29| 262k| { 30| |#ifdef _MSC_VER 31| | return std::countr_zero(x); 32| |#else 33| 262k|#if __has_builtin(__builtin_ctzll) 34| 262k| return __builtin_ctzll(x); 35| |#else 36| | return std::countr_zero(x); 37| |#endif 38| 262k|#endif 39| 262k| } _ZN3glz11countr_zeroEj: 16| 48.1k| { 17| |#ifdef _MSC_VER 18| | return std::countr_zero(x); 19| |#else 20| 48.1k|#if __has_builtin(__builtin_ctzl) 21| 48.1k| return __builtin_ctzl(x); 22| |#else 23| | return std::countr_zero(x); 24| |#endif 25| 48.1k|#endif 26| 48.1k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 28.3k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| | else if constexpr (N == 6) { 268| | static constexpr auto packed = pack_buffered(); 269| | uint64_t in{}; 270| | std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| | return (in == packed); 275| | } 276| | else if constexpr (N == 5) { 277| | static constexpr auto packed = pack(); 278| | uint32_t in; 279| | std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| | return (in == packed) & (Str[4] == other[4]); 284| | } 285| | else if constexpr (N == 4) { 286| | static constexpr auto packed = pack(); 287| | uint32_t in; 288| | std::memcpy(&in, other, 4); 289| | if constexpr (std::endian::native == std::endian::big) { 290| | in = std::byteswap(in); 291| | } 292| | return (in == packed); 293| | } 294| | else if constexpr (N == 3) { 295| | static constexpr auto packed = pack(); 296| | uint16_t in; 297| | std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| | return (in == packed) & (Str[2] == other[2]); 302| | } 303| 28.3k| else if constexpr (N == 2) { 304| 28.3k| static constexpr auto packed = pack(); 305| 28.3k| uint16_t in; 306| 28.3k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 28.3k| return (in == packed); 311| | } 312| | else if constexpr (N == 1) { 313| | return Str[0] == other[0]; 314| | } 315| | else if constexpr (N == 0) { 316| | return true; 317| | } 318| | else { 319| | // Clang and GCC optimize this extremely well for constexpr std::string_view 320| | // Packing data can create more binary on GCC 321| | // The other cases probably aren't needed as compiler explorer shows them optimized equally well as memcmp 322| | return 0 == std::memcmp(Str.data(), other, N); 323| | } 324| 28.3k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz5pointELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm2EcEEbPKT1_: 245| 36.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| 36.1k| else if constexpr (N == 2) { 304| 36.1k| static constexpr auto packed = pack(); 305| 36.1k| uint16_t in; 306| 36.1k| std::memcpy(&in, other, 2); 307| | if constexpr (std::endian::native == std::endian::big) { 308| | in = std::byteswap(in); 309| | } 310| 36.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| 36.1k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 194| { 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| 194| else if constexpr (N == 6) { 268| 194| static constexpr auto packed = pack_buffered(); 269| 194| uint64_t in{}; 270| 194| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 194| 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| 194| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6nestedELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 21.2k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 21.2k| else if constexpr (N == 6) { 268| 21.2k| static constexpr auto packed = pack_buffered(); 269| 21.2k| uint64_t in{}; 270| 21.2k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 21.2k| 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| 21.2k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 38.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| 38.4k| else if constexpr (N == 6) { 268| 38.4k| static constexpr auto packed = pack_buffered(); 269| 38.4k| uint64_t in{}; 270| 38.4k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 38.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| 38.4k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm1ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm5EcEEbPKT1_: 245| 139| { 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| 139| else if constexpr (N == 5) { 277| 139| static constexpr auto packed = pack(); 278| 139| uint32_t in; 279| 139| std::memcpy(&in, other, 4); 280| | if constexpr (std::endian::native == std::endian::big) { 281| | in = std::byteswap(in); 282| | } 283| 139| 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| 139| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm2ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 977| { 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| 977| 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| 977| return 0 == std::memcmp(Str.data(), other, N); 323| 977| } 324| 977| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm3ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 812| { 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| 812| else if constexpr (N == 6) { 268| 812| static constexpr auto packed = pack_buffered(); 269| 812| uint64_t in{}; 270| 812| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 812| 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| 812| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm4ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm7EcEEbPKT1_: 245| 9.38k| { 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| 9.38k| else if constexpr (N == 7) { 259| 9.38k| static constexpr auto packed = pack_buffered(); 260| 9.38k| uint64_t in{}; 261| 9.38k| std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| 9.38k| 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| 9.38k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm5ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 1.48k| { 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.48k| else if constexpr (N == 6) { 268| 1.48k| static constexpr auto packed = pack_buffered(); 269| 1.48k| uint64_t in{}; 270| 1.48k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 1.48k| 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.48k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm6ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 2.42k| { 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| 2.42k| else if constexpr (N == 6) { 268| 2.42k| static constexpr auto packed = pack_buffered(); 269| 2.42k| uint64_t in{}; 270| 2.42k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 2.42k| 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| 2.42k| } _ZN3glz10comparitorIL_ZZNS_5matchITnNS_14string_literalEXtlNS2_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS9_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_E1SELm3EcEEbPKSB_: 245| 1.15k| { 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.15k| else if constexpr (N == 3) { 295| 1.15k| static constexpr auto packed = pack(); 296| 1.15k| uint16_t in; 297| 1.15k| std::memcpy(&in, other, 2); 298| | if constexpr (std::endian::native == std::endian::big) { 299| | in = std::byteswap(in); 300| | } 301| 1.15k| 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.15k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm7ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 9.13k| { 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| 9.13k| if constexpr (N == 8) { 250| 9.13k| static constexpr auto packed = pack(); 251| 9.13k| uint64_t in; 252| 9.13k| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 9.13k| 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| 9.13k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz6amountELm0ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 26.3k| { 246| | // pack() builds values in little-endian order (byte 0 in LSB position). 247| | // On big-endian systems, memcpy produces native (big-endian) values, 248| | // so we need to byteswap to match the packed representation. 249| | if constexpr (N == 8) { 250| | static constexpr auto packed = pack(); 251| | uint64_t in; 252| | std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| | return (in == packed); 257| | } 258| | else if constexpr (N == 7) { 259| | static constexpr auto packed = pack_buffered(); 260| | uint64_t in{}; 261| | std::memcpy(&in, other, 7); 262| | if constexpr (std::endian::native == std::endian::big) { 263| | in = std::byteswap(in); 264| | } 265| | return (in == packed); 266| | } 267| 26.3k| else if constexpr (N == 6) { 268| 26.3k| static constexpr auto packed = pack_buffered(); 269| 26.3k| uint64_t in{}; 270| 26.3k| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 26.3k| 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| 26.3k| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm8ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm8EcEEbPKT1_: 245| 315| { 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| 315| if constexpr (N == 8) { 250| 315| static constexpr auto packed = pack(); 251| 315| uint64_t in; 252| 315| std::memcpy(&in, other, 8); 253| | if constexpr (std::endian::native == std::endian::big) { 254| | in = std::byteswap(in); 255| | } 256| 315| 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| 315| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm9ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 121| { 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| 121| else if constexpr (N == 6) { 268| 121| static constexpr auto packed = pack_buffered(); 269| 121| uint64_t in{}; 270| 121| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 121| 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| 121| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm10ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm9EcEEbPKT1_: 245| 343| { 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| 343| 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| 343| return 0 == std::memcmp(Str.data(), other, N); 323| 343| } 324| 343| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm11ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 96| { 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| 96| else if constexpr (N == 6) { 268| 96| static constexpr auto packed = pack_buffered(); 269| 96| uint64_t in{}; 270| 96| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 96| 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| 96| } _ZN3glz10comparitorIL_ZZNS_12decode_indexITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiELm12ERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT2_OT4_OT5_OT6_DpOT3_E15KeyWithEndQuoteELm6EcEEbPKT1_: 245| 101| { 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| 101| else if constexpr (N == 6) { 268| 101| static constexpr auto packed = pack_buffered(); 269| 101| uint64_t in{}; 270| 101| std::memcpy(&in, other, 6); 271| | if constexpr (std::endian::native == std::endian::big) { 272| | in = std::byteswap(in); 273| | } 274| 101| 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| 101| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 82| 438k| { 83| 438k| if constexpr (Checked && vector_like) { 84| 438k| if (ix == b.size()) [[unlikely]] { ------------------ | Branch (84:14): [True: 0, False: 438k] ------------------ 85| 0| b.resize(b.size() == 0 ? 128 : b.size() * 2); ------------------ | Branch (85:22): [True: 0, False: 0] ------------------ 86| 0| } 87| 438k| } 88| 438k| assign_maybe_cast(c, b, ix); 89| 438k| ++ix; 90| 438k| } _ZN3glz17assign_maybe_castITkNS_10byte_sizedEcNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvT_RT0_Rm: 55| 439k| { 56| 439k| using V = std::decay_t; 57| 439k| using C = std::decay_t; 58| 439k| if constexpr (std::same_as) { 59| 439k| b[ix] = c; 60| | } 61| | else { 62| | b[ix] = static_cast(c); 63| | } 64| 439k| } _ZN3glz4dumpILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 124| 448k| { 125| 448k| const auto n = str.size(); 126| 448k| if constexpr (vector_like) { 127| 448k| if constexpr (Checked) { 128| 448k| const auto k = ix + n; 129| 448k| if (ix + n > b.size()) [[unlikely]] { ------------------ | Branch (129:17): [True: 0, False: 448k] ------------------ 130| 0| b.resize(2 * k); 131| 0| } 132| 448k| } 133| 448k| } 134| 448k| std::memcpy(&b[ix], str.data(), n); 135| 448k| ix += n; 136| 448k| } _ZN3glz16dump_maybe_emptyILb1ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvNS1_17basic_string_viewIcS4_EERT0_Rm: 251| 297k| { 252| 297k| const auto n = str.size(); 253| 297k| if (n) { ------------------ | Branch (253:11): [True: 297k, False: 0] ------------------ 254| 297k| if constexpr (vector_like) { 255| 297k| if constexpr (Checked) { 256| 297k| const auto k = ix + n; 257| 297k| if (k > b.size()) [[unlikely]] { ------------------ | Branch (257:20): [True: 0, False: 297k] ------------------ 258| 0| b.resize(2 * k); 259| 0| } 260| 297k| } 261| 297k| } 262| 297k| std::memcpy(&b[ix], str.data(), n); 263| 297k| ix += n; 264| 297k| } 265| 297k| } _ZN3glz5dumpnINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT0_mRT_Rm: 154| 146k| { 155| 146k| if constexpr (vector_like) { 156| 146k| const auto k = ix + n; 157| 146k| if (k > b.size()) [[unlikely]] { ------------------ | Branch (157:14): [True: 0, False: 146k] ------------------ 158| 0| b.resize(2 * k); 159| 0| } 160| 146k| } 161| 146k| std::memset(&b[ix], c, n); 162| 146k| ix += n; 163| 146k| } _ZN3glz4dumpILb0ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEETkNS_10byte_sizedEcEEvT1_RT0_Rm: 82| 272| { 83| | if constexpr (Checked && vector_like) { 84| | if (ix == b.size()) [[unlikely]] { 85| | b.resize(b.size() == 0 ? 128 : b.size() * 2); 86| | } 87| | } 88| 272| assign_maybe_cast(c, b, ix); 89| 272| ++ix; 90| 272| } _ZN3glz10fast_float4spanIKcEC2Ev: 438| 629k| constexpr span() : ptr(nullptr), length(0) {} _ZN3glz10fast_float10is_integerIcEEbT_: 1481| 37.6k|fastfloat_really_inline constexpr bool is_integer(UC c) noexcept { 1482| 37.6k| return !(c > UC('9') || c < UC('0')); ------------------ | Branch (1482:12): [True: 13, False: 37.6k] | Branch (1482:27): [True: 41, False: 37.5k] ------------------ 1483| 37.6k|} _ZN3glz10fast_float11digit_valueIcEEmT_: 1489| 3.72M|fastfloat_really_inline constexpr uint64_t digit_value(UC c) noexcept { 1490| 3.72M| return uint64_t(uint8_t(c) - uint8_t('0')); 1491| 3.72M|} _ZN3glz10fast_float4spanIKcEC2EPS2_m: 436| 340k| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float26loop_parse_if_eight_digitsERPKcS2_Rm: 1679| 25.6k| uint64_t &i) { 1680| | // optimizes better than parse_if_eight_digits_unrolled() for UC = char. 1681| 967k| while ((std::distance(p, pend) >= 8) && ------------------ | Branch (1681:10): [True: 966k, False: 1.54k] ------------------ 1682| 966k| is_made_of_eight_digits_fast(read8_to_u64(p))) { ------------------ | Branch (1682:10): [True: 942k, False: 24.1k] ------------------ 1683| 942k| i = i * 100000000 + 1684| 942k| parse_eight_digits_unrolled(read8_to_u64( 1685| 942k| p)); // in rare cases, this will overflow, but that's ok 1686| 942k| p += 8; 1687| 942k| } 1688| 25.6k|} _ZN3glz10fast_float28is_made_of_eight_digits_fastEm: 1597| 966k|is_made_of_eight_digits_fast(uint64_t val) noexcept { 1598| 966k| return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) & 1599| 966k| 0x8080808080808080)); 1600| 966k|} _ZN3glz10fast_float12read8_to_u64IcEEmPKT_: 1503| 2.27M|read8_to_u64(UC const *chars) { 1504| 2.27M| 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| 2.27M| uint64_t val; 1513| 2.27M| ::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| 2.27M| return val; 1519| 2.27M|} _ZN3glz10fast_float27parse_eight_digits_unrolledEm: 1575| 1.30M|parse_eight_digits_unrolled(uint64_t val) { 1576| 1.30M| uint64_t const mask = 0x000000FF000000FF; 1577| 1.30M| uint64_t const mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32) 1578| 1.30M| uint64_t const mul2 = 0x0000271000000001; // 1 + (10000ULL << 32) 1579| 1.30M| val -= 0x3030303030303030; 1580| 1.30M| val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8; 1581| 1.30M| val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32; 1582| 1.30M| return uint32_t(val); 1583| 1.30M|} _ZNK3glz10fast_float4spanIKcE3lenEv: 440| 72.2k| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float19from_chars_advancedIdcEENS0_19from_chars_result_tIT0_EERNS0_22parsed_number_string_tIS3_EERT_: 4249| 291k|from_chars_advanced(parsed_number_string_t &pns, T &value) noexcept { 4250| | 4251| 291k| static_assert(is_supported_float_type::value, 4252| 291k| "only some floating-point types are supported"); 4253| 291k| static_assert(is_supported_char_type::value, 4254| 291k| "only char, wchar_t, char16_t and char32_t are supported"); 4255| | 4256| 291k| from_chars_result_t answer; 4257| | 4258| 291k| answer.ec = std::errc(); // be optimistic 4259| 291k| 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| 291k| if (binary_format::min_exponent_fast_path() <= pns.exponent && ------------------ | Branch (4265:7): [True: 287k, False: 3.46k] ------------------ 4266| 287k| pns.exponent <= binary_format::max_exponent_fast_path() && ------------------ | Branch (4266:7): [True: 278k, False: 9.48k] ------------------ 4267| 278k| !pns.too_many_digits) { ------------------ | Branch (4267:7): [True: 257k, False: 20.8k] ------------------ 4268| | // Unfortunately, the conventional Clinger's fast path is only possible 4269| | // when the system rounds to the nearest float. 4270| | // 4271| | // We expect the next branch to almost always be selected. 4272| | // We could check it first (before the previous branch), but 4273| | // there might be performance advantages at having the check 4274| | // be last. 4275| 257k| if (!cpp20_and_in_constexpr() && detail::rounds_to_nearest()) { ------------------ | Branch (4275:9): [True: 257k, Folded] | Branch (4275:38): [True: 257k, False: 0] ------------------ 4276| | // We have that fegetround() == FE_TONEAREST. 4277| | // Next is Clinger's fast path. 4278| 257k| if (pns.mantissa <= binary_format::max_mantissa_fast_path()) { ------------------ | Branch (4278:11): [True: 255k, False: 2.32k] ------------------ 4279| 255k| value = T(pns.mantissa); 4280| 255k| if (pns.exponent < 0) { ------------------ | Branch (4280:13): [True: 2.51k, False: 252k] ------------------ 4281| 2.51k| value = value / binary_format::exact_power_of_ten(-pns.exponent); 4282| 252k| } else { 4283| 252k| value = value * binary_format::exact_power_of_ten(pns.exponent); 4284| 252k| } 4285| 255k| if (pns.negative) { ------------------ | Branch (4285:13): [True: 37.1k, False: 217k] ------------------ 4286| 37.1k| value = -value; 4287| 37.1k| } 4288| 255k| return answer; 4289| 255k| } 4290| 257k| } 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| 257k| } 4313| 36.0k| adjusted_mantissa am = 4314| 36.0k| compute_float>(pns.exponent, pns.mantissa); 4315| 36.0k| if (pns.too_many_digits && am.power2 >= 0) { ------------------ | Branch (4315:7): [True: 30.1k, False: 5.94k] | Branch (4315:30): [True: 30.1k, False: 0] ------------------ 4316| 30.1k| if (am != compute_float>(pns.exponent, pns.mantissa + 1)) { ------------------ | Branch (4316:9): [True: 16.2k, False: 13.8k] ------------------ 4317| 16.2k| am = compute_error>(pns.exponent, pns.mantissa); 4318| 16.2k| } 4319| 30.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| 36.0k| if (am.power2 < 0) { ------------------ | Branch (4323:7): [True: 16.2k, False: 19.7k] ------------------ 4324| 16.2k| am = digit_comp(pns, am); 4325| 16.2k| } 4326| 36.0k| to_float(pns.negative, am, value); 4327| | // Test for over/underflow. 4328| 36.0k| if ((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) || ------------------ | Branch (4328:8): [True: 34.7k, False: 1.35k] | Branch (4328:29): [True: 1.37k, False: 33.3k] | Branch (4328:49): [True: 133, False: 1.24k] ------------------ 4329| 35.9k| am.power2 == binary_format::infinite_power()) { ------------------ | Branch (4329:7): [True: 251, False: 35.6k] ------------------ 4330| 384| answer.ec = std::errc::result_out_of_range; 4331| 384| } 4332| 36.0k| return answer; 4333| 291k|} _ZN3glz10fast_float13binary_formatIdE22min_exponent_fast_pathEv: 695| 291k|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| 291k| return -22; 700| 291k|#endif 701| 291k|} _ZN3glz10fast_float13binary_formatIdE22max_exponent_fast_pathEv: 767| 287k|inline constexpr int binary_format::max_exponent_fast_path() { 768| 287k| return 22; 769| 287k|} _ZN3glz10fast_float6detail17rounds_to_nearestEv: 4129| 257k|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| 257k| static float volatile fmin = (std::numeric_limits::min)(); 4151| 257k| 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| 257k|#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| 257k| 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| 257k|} _ZN3glz10fast_float13binary_formatIdE22max_mantissa_fast_pathEv: 777| 257k|inline constexpr uint64_t binary_format::max_mantissa_fast_path() { 778| 257k| return uint64_t(2) << mantissa_explicit_bits(); 779| 257k|} _ZN3glz10fast_float13binary_formatIdE22mantissa_explicit_bitsEv: 713| 634k|inline constexpr int binary_format::mantissa_explicit_bits() { 714| 634k| return 52; 715| 634k|} _ZN3glz10fast_float13binary_formatIdE18exact_power_of_tenEl: 1057| 255k|binary_format::exact_power_of_ten(int64_t power) { 1058| | // Work around clang bug https://godbolt.org/z/zedh7rrhc 1059| 255k| return (void)powers_of_ten[0], powers_of_ten[power]; 1060| 255k|} _ZN3glz10fast_float13compute_floatINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2852| 66.2k|compute_float(int64_t q, uint64_t w) noexcept { 2853| 66.2k| adjusted_mantissa answer; 2854| 66.2k| if ((w == 0) || (q < binary::smallest_power_of_ten())) { ------------------ | Branch (2854:7): [True: 1.35k, False: 64.8k] | Branch (2854:19): [True: 143, False: 64.7k] ------------------ 2855| 1.50k| answer.power2 = 0; 2856| 1.50k| answer.mantissa = 0; 2857| | // result should be zero 2858| 1.50k| return answer; 2859| 1.50k| } 2860| 64.7k| if (q > binary::largest_power_of_ten()) { ------------------ | Branch (2860:7): [True: 295, False: 64.4k] ------------------ 2861| | // we want to get infinity: 2862| 295| answer.power2 = binary::infinite_power(); 2863| 295| answer.mantissa = 0; 2864| 295| return answer; 2865| 295| } 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| 64.4k| int lz = leading_zeroes(w); 2871| 64.4k| 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| 64.4k| value128 product = 2880| 64.4k| 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| 64.4k| int upperbit = int(product.high >> 63); 2891| 64.4k| int shift = upperbit + 64 - binary::mantissa_explicit_bits() - 3; 2892| | 2893| 64.4k| answer.mantissa = product.high >> shift; 2894| | 2895| 64.4k| answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - 2896| 64.4k| binary::minimum_exponent()); 2897| 64.4k| if (answer.power2 <= 0) { // we have a subnormal? ------------------ | Branch (2897:7): [True: 520, False: 63.8k] ------------------ 2898| | // Here have that answer.power2 <= 0 so -answer.power2 >= 0 2899| 520| if (-answer.power2 + 1 >= ------------------ | Branch (2899:9): [True: 12, False: 508] ------------------ 2900| 520| 64) { // if we have more than 64 bits below the minimum exponent, you 2901| | // have a zero for sure. 2902| 12| answer.power2 = 0; 2903| 12| answer.mantissa = 0; 2904| | // result should be zero 2905| 12| return answer; 2906| 12| } 2907| | // next line is safe because -answer.power2 + 1 < 64 2908| 508| 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| 508| answer.mantissa += (answer.mantissa & 1); // round up 2913| 508| 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| 508| answer.power2 = 2922| 508| (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ------------------ | Branch (2922:9): [True: 508, False: 0] ------------------ 2923| 508| ? 0 2924| 508| : 1; 2925| 508| return answer; 2926| 520| } 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| 63.8k| if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) && ------------------ | Branch (2931:7): [True: 16.5k, False: 47.3k] | Branch (2931:29): [True: 15.6k, False: 916] ------------------ 2932| 15.6k| (q <= binary::max_exponent_round_to_even()) && ------------------ | Branch (2932:7): [True: 15.1k, False: 501] ------------------ 2933| 15.1k| ((answer.mantissa & 3) == 1)) { // we may fall between two floats! ------------------ | Branch (2933:7): [True: 4.43k, False: 10.7k] ------------------ 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| 4.43k| if ((answer.mantissa << shift) == product.high) { ------------------ | Branch (2939:9): [True: 1.64k, False: 2.78k] ------------------ 2940| 1.64k| answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up 2941| 1.64k| } 2942| 4.43k| } 2943| | 2944| 63.8k| answer.mantissa += (answer.mantissa & 1); // round up 2945| 63.8k| answer.mantissa >>= 1; 2946| 63.8k| if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) { ------------------ | Branch (2946:7): [True: 1.06k, False: 62.8k] ------------------ 2947| 1.06k| answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits()); 2948| 1.06k| answer.power2++; // undo previous addition 2949| 1.06k| } 2950| | 2951| 63.8k| answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits()); 2952| 63.8k| if (answer.power2 >= binary::infinite_power()) { // infinity ------------------ | Branch (2952:7): [True: 26, False: 63.8k] ------------------ 2953| 26| answer.power2 = binary::infinite_power(); 2954| 26| answer.mantissa = 0; 2955| 26| } 2956| 63.8k| return answer; 2957| 64.4k|} _ZN3glz10fast_float17adjusted_mantissaC2Ev: 568| 98.7k| adjusted_mantissa() = default; _ZN3glz10fast_float13binary_formatIdE21smallest_power_of_tenEv: 1077| 64.8k|inline constexpr int binary_format::smallest_power_of_ten() { 1078| 64.8k| return -342; 1079| 64.8k|} _ZN3glz10fast_float13binary_formatIdE20largest_power_of_tenEv: 1068| 64.7k|template <> inline constexpr int binary_format::largest_power_of_ten() { 1069| 64.7k| return 308; 1070| 64.7k|} _ZN3glz10fast_float14leading_zeroesEm: 488| 87.3k|leading_zeroes(uint64_t input_num) { 489| 87.3k| assert(input_num > 0); ------------------ | Branch (489:3): [True: 87.3k, False: 0] ------------------ 490| 87.3k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (490:7): [Folded, False: 87.3k] ------------------ 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| 87.3k| return __builtin_clzll(input_num); 505| 87.3k|#endif 506| 87.3k|} _ZN3glz10fast_float29compute_product_approximationILi55EEENS0_8value128Elm: 2771| 80.7k|compute_product_approximation(int64_t q, uint64_t w) { 2772| 80.7k| 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| 80.7k| value128 firstproduct = 2777| 80.7k| full_multiplication(w, powers::power_of_five_128[index]); 2778| 80.7k| static_assert((bit_precision >= 0) && (bit_precision <= 64), 2779| 80.7k| " precision should be in (0,64]"); 2780| 80.7k| constexpr uint64_t precision_mask = 2781| 80.7k| (bit_precision < 64) ? (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision) ------------------ | Branch (2781:7): [True: 0, Folded] ------------------ 2782| 80.7k| : uint64_t(0xFFFFFFFFFFFFFFFF); 2783| 80.7k| if ((firstproduct.high & precision_mask) == ------------------ | Branch (2783:7): [True: 9.34k, False: 71.3k] ------------------ 2784| 80.7k| 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| 9.34k| value128 secondproduct = 2789| 9.34k| full_multiplication(w, powers::power_of_five_128[index + 1]); 2790| 9.34k| firstproduct.low += secondproduct.high; 2791| 9.34k| if (secondproduct.high > firstproduct.low) { ------------------ | Branch (2791:9): [True: 3.82k, False: 5.51k] ------------------ 2792| 3.82k| firstproduct.high++; 2793| 3.82k| } 2794| 9.34k| } 2795| 80.7k| return firstproduct; 2796| 80.7k|} _ZN3glz10fast_float19full_multiplicationEmm: 540| 90.0k|full_multiplication(uint64_t a, uint64_t b) { 541| 90.0k| if (cpp20_and_in_constexpr()) { ------------------ | Branch (541:7): [Folded, False: 90.0k] ------------------ 542| 0| value128 answer; 543| 0| answer.low = umul128_generic(a, b, &answer.high); 544| 0| return answer; 545| 0| } 546| 90.0k| 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| 90.0k| answer.low = uint64_t(r); 558| 90.0k| answer.high = uint64_t(r >> 64); 559| |#else 560| | answer.low = umul128_generic(a, b, &answer.high); 561| |#endif 562| 90.0k| return answer; 563| 90.0k|} _ZN3glz10fast_float8value128C2Ev: 454| 90.0k| constexpr value128() : low(0), high(0) {} _ZN3glz10fast_float6detail5powerEi: 2814| 80.7k|constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept { 2815| 80.7k| return (((152170 + 65536) * q) >> 16) + 63; 2816| 80.7k|} _ZN3glz10fast_float13binary_formatIdE16minimum_exponentEv: 742| 96.9k|template <> inline constexpr int binary_format::minimum_exponent() { 743| 96.9k| return -1023; 744| 96.9k|} _ZN3glz10fast_float13binary_formatIdE26min_exponent_round_to_evenEv: 733| 16.5k|inline constexpr int binary_format::min_exponent_round_to_even() { 734| 16.5k| return -4; 735| 16.5k|} _ZN3glz10fast_float13binary_formatIdE26max_exponent_round_to_evenEv: 723| 15.6k|inline constexpr int binary_format::max_exponent_round_to_even() { 724| 15.6k| return 23; 725| 15.6k|} _ZNK3glz10fast_float17adjusted_mantissaneERKS1_: 574| 30.1k| constexpr bool operator!=(adjusted_mantissa const &o) const { 575| 30.1k| return mantissa != o.mantissa || power2 != o.power2; ------------------ | Branch (575:12): [True: 16.2k, False: 13.8k] | Branch (575:38): [True: 0, False: 13.8k] ------------------ 576| 30.1k| } _ZN3glz10fast_float13compute_errorINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElm: 2837| 16.2k|compute_error(int64_t q, uint64_t w) noexcept { 2838| 16.2k| int lz = leading_zeroes(w); 2839| 16.2k| w <<= lz; 2840| 16.2k| value128 product = 2841| 16.2k| compute_product_approximation(q, w); 2842| 16.2k| return compute_error_scaled(q, product.high, lz); 2843| 16.2k|} _ZN3glz10fast_float20compute_error_scaledINS0_13binary_formatIdEEEENS0_17adjusted_mantissaElmi: 2823| 16.2k|compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept { 2824| 16.2k| int hilz = int(w >> 63) ^ 1; 2825| 16.2k| adjusted_mantissa answer; 2826| 16.2k| answer.mantissa = w << hilz; 2827| 16.2k| int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent(); 2828| 16.2k| answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + 2829| 16.2k| invalid_am_bias); 2830| 16.2k| return answer; 2831| 16.2k|} _ZN3glz10fast_float10digit_compIdcEENS0_17adjusted_mantissaERNS0_22parsed_number_string_tIT0_EES2_: 4034| 16.2k|digit_comp(parsed_number_string_t &num, adjusted_mantissa am) noexcept { 4035| | // remove the invalid exponent bias 4036| 16.2k| am.power2 -= invalid_am_bias; 4037| | 4038| 16.2k| int32_t sci_exp = scientific_exponent(num); 4039| 16.2k| size_t max_digits = binary_format::max_digits(); 4040| 16.2k| size_t digits = 0; 4041| 16.2k| bigint bigmant; 4042| 16.2k| parse_mantissa(bigmant, num, max_digits, digits); 4043| | // can't underflow, since digits is at most max_digits. 4044| 16.2k| int32_t exponent = sci_exp + 1 - int32_t(digits); 4045| 16.2k| if (exponent >= 0) { ------------------ | Branch (4045:7): [True: 3.31k, False: 12.9k] ------------------ 4046| 3.31k| return positive_digit_comp(bigmant, exponent); 4047| 12.9k| } else { 4048| 12.9k| return negative_digit_comp(bigmant, am, exponent); 4049| 12.9k| } 4050| 16.2k|} _ZN3glz10fast_float19scientific_exponentIcEEiRNS0_22parsed_number_string_tIT_EE: 3640| 16.2k|scientific_exponent(parsed_number_string_t &num) noexcept { 3641| 16.2k| uint64_t mantissa = num.mantissa; 3642| 16.2k| int32_t exponent = int32_t(num.exponent); 3643| 81.4k| while (mantissa >= 10000) { ------------------ | Branch (3643:10): [True: 65.1k, False: 16.2k] ------------------ 3644| 65.1k| mantissa /= 10000; 3645| 65.1k| exponent += 4; 3646| 65.1k| } 3647| 32.5k| while (mantissa >= 100) { ------------------ | Branch (3647:10): [True: 16.2k, False: 16.2k] ------------------ 3648| 16.2k| mantissa /= 100; 3649| 16.2k| exponent += 2; 3650| 16.2k| } 3651| 16.2k| while (mantissa >= 10) { ------------------ | Branch (3651:10): [True: 0, False: 16.2k] ------------------ 3652| 0| mantissa /= 10; 3653| 0| exponent += 1; 3654| 0| } 3655| 16.2k| return exponent; 3656| 16.2k|} _ZN3glz10fast_float13binary_formatIdE10max_digitsEv: 1085| 16.2k|template <> inline constexpr size_t binary_format::max_digits() { 1086| 16.2k| return 769; 1087| 16.2k|} _ZN3glz10fast_float6bigintC2Ev: 3399| 16.2k| GLZ_FASTFLOAT_CONSTEXPR20 bigint() : vec() {} _ZN3glz10fast_float8stackvecILt62EEC2Ev: 3006| 89.2k| stackvec() = default; _ZN3glz10fast_float14parse_mantissaIcEEvRNS0_6bigintERNS0_22parsed_number_string_tIT_EEmRm: 3859| 16.2k| 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| 16.2k| size_t counter = 0; 3864| 16.2k| digits = 0; 3865| 16.2k| limb value = 0; 3866| 16.2k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3867| 16.2k| size_t step = 19; 3868| |#else 3869| | size_t step = 9; 3870| |#endif 3871| | 3872| | // process all integer digits. 3873| 16.2k| UC const *p = num.integer.ptr; 3874| 16.2k| UC const *pend = p + num.integer.len(); 3875| 16.2k| skip_zeros(p, pend); 3876| | // process all digits, in increments of step per loop 3877| 70.3k| while (p != pend) { ------------------ | Branch (3877:10): [True: 54.0k, False: 16.2k] ------------------ 3878| 138k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3878:12): [True: 118k, False: 20.3k] | Branch (3878:45): [True: 84.6k, False: 33.6k] ------------------ 3879| 84.6k| (max_digits - digits >= 8)) { ------------------ | Branch (3879:12): [True: 84.6k, False: 0] ------------------ 3880| 84.6k| parse_eight_digits(p, value, counter, digits); 3881| 84.6k| } 3882| 219k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3882:12): [True: 180k, False: 39.2k] | Branch (3882:30): [True: 165k, False: 14.7k] | Branch (3882:43): [True: 165k, False: 0] ------------------ 3883| 165k| parse_one_digit(p, value, counter, digits); 3884| 165k| } 3885| 54.0k| if (digits == max_digits) { ------------------ | Branch (3885:9): [True: 0, False: 54.0k] ------------------ 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| 54.0k| } else { 3897| 54.0k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3898| 54.0k| counter = 0; 3899| 54.0k| value = 0; 3900| 54.0k| } 3901| 54.0k| } 3902| | 3903| | // add our fraction digits, if they're available. 3904| 16.2k| if (num.fraction.ptr != nullptr) { ------------------ | Branch (3904:7): [True: 12.9k, False: 3.29k] ------------------ 3905| 12.9k| p = num.fraction.ptr; 3906| 12.9k| pend = p + num.fraction.len(); 3907| 12.9k| if (digits == 0) { ------------------ | Branch (3907:9): [True: 1.38k, False: 11.6k] ------------------ 3908| 1.38k| skip_zeros(p, pend); 3909| 1.38k| } 3910| | // process all digits, in increments of step per loop 3911| 157k| while (p != pend) { ------------------ | Branch (3911:12): [True: 147k, False: 10.2k] ------------------ 3912| 429k| while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && ------------------ | Branch (3912:14): [True: 416k, False: 12.8k] | Branch (3912:47): [True: 283k, False: 133k] ------------------ 3913| 283k| (max_digits - digits >= 8)) { ------------------ | Branch (3913:14): [True: 282k, False: 1.04k] ------------------ 3914| 282k| parse_eight_digits(p, value, counter, digits); 3915| 282k| } 3916| 586k| while (counter < step && p != pend && digits < max_digits) { ------------------ | Branch (3916:14): [True: 451k, False: 135k] | Branch (3916:32): [True: 441k, False: 10.4k] | Branch (3916:45): [True: 439k, False: 2.12k] ------------------ 3917| 439k| parse_one_digit(p, value, counter, digits); 3918| 439k| } 3919| 147k| if (digits == max_digits) { ------------------ | Branch (3919:11): [True: 2.74k, False: 144k] ------------------ 3920| | // add the temporary value, then check if we've truncated any digits 3921| 2.74k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3922| 2.74k| bool truncated = is_truncated(p, pend); 3923| 2.74k| if (truncated) { ------------------ | Branch (3923:13): [True: 1.54k, False: 1.20k] ------------------ 3924| 1.54k| round_up_bigint(result, digits); 3925| 1.54k| } 3926| 2.74k| return; 3927| 144k| } else { 3928| 144k| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3929| 144k| counter = 0; 3930| 144k| value = 0; 3931| 144k| } 3932| 147k| } 3933| 12.9k| } 3934| | 3935| 13.5k| if (counter != 0) { ------------------ | Branch (3935:7): [True: 0, False: 13.5k] ------------------ 3936| 0| add_native(result, limb(powers_of_ten_uint64[counter]), value); 3937| 0| } 3938| 13.5k|} _ZN3glz10fast_float10skip_zerosIcEEvRPKT_S4_: 3773| 17.6k|skip_zeros(UC const *&first, UC const *last) noexcept { 3774| 17.6k| uint64_t val; 3775| 19.9k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3775:10): [True: 19.9k, Folded] ------------------ 3776| 19.9k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3776:10): [True: 14.3k, False: 5.56k] ------------------ 3777| 14.3k| ::memcpy(&val, first, sizeof(uint64_t)); 3778| 14.3k| if (val != int_cmp_zeros()) { ------------------ | Branch (3778:9): [True: 12.1k, False: 2.26k] ------------------ 3779| 12.1k| break; 3780| 12.1k| } 3781| 2.26k| first += int_cmp_len(); 3782| 2.26k| } 3783| 21.9k| while (first != last) { ------------------ | Branch (3783:10): [True: 20.5k, False: 1.38k] ------------------ 3784| 20.5k| if (*first != UC('0')) { ------------------ | Branch (3784:9): [True: 16.2k, False: 4.27k] ------------------ 3785| 16.2k| break; 3786| 16.2k| } 3787| 4.27k| first++; 3788| 4.27k| } 3789| 17.6k|} _ZN3glz10fast_float11int_cmp_lenIcEEiv: 1180| 375k|template constexpr int int_cmp_len() { 1181| 375k| return sizeof(uint64_t) / sizeof(UC); 1182| 375k|} _ZN3glz10fast_float13int_cmp_zerosIcEEmv: 1170| 190k|template constexpr uint64_t int_cmp_zeros() { 1171| 190k| static_assert((sizeof(UC) == 1) || (sizeof(UC) == 2) || (sizeof(UC) == 4), 1172| 190k| "Unsupported character size"); 1173| 190k| return (sizeof(UC) == 1) ? 0x3030303030303030 ------------------ | Branch (1173:10): [True: 190k, Folded] ------------------ 1174| 190k| : (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| 190k|} _ZN3glz10fast_float18parse_eight_digitsIcEEvRPKT_RmS6_S6_: 3824| 366k| size_t &count) noexcept { 3825| 366k| value = value * 100000000 + parse_eight_digits_unrolled(p); 3826| 366k| p += 8; 3827| 366k| counter += 8; 3828| 366k| count += 8; 3829| 366k|} _ZN3glz10fast_float27parse_eight_digits_unrolledIcEEjPKT_: 1588| 366k|parse_eight_digits_unrolled(UC const *chars) noexcept { 1589| 366k| if (cpp20_and_in_constexpr() || !has_simd_opt()) { ------------------ | Branch (1589:7): [Folded, False: 0] | Branch (1589:35): [True: 0, Folded] ------------------ 1590| 366k| return parse_eight_digits_unrolled(read8_to_u64(chars)); // truncation okay 1591| 366k| } 1592| 0| return parse_eight_digits_unrolled(simd_read8_to_u64(chars)); 1593| 366k|} _ZN3glz10fast_float15parse_one_digitIcEEvRPKT_RmS6_S6_: 3834| 604k| size_t &count) noexcept { 3835| 604k| value = value * 10 + limb(*p - UC('0')); 3836| 604k| p++; 3837| 604k| counter++; 3838| 604k| count++; 3839| 604k|} _ZN3glz10fast_float10add_nativeERNS0_6bigintEmm: 3842| 203k|add_native(bigint &big, limb power, limb value) noexcept { 3843| 203k| big.mul(power); 3844| 203k| big.add(value); 3845| 203k|} _ZN3glz10fast_float6bigint3mulEm: 3552| 203k| GLZ_FASTFLOAT_CONSTEXPR20 bool mul(limb y) noexcept { return small_mul(vec, y); } _ZN3glz10fast_float9small_mulILt62EEEbRNS0_8stackvecIXT_EEEm: 3249| 312k| limb y) noexcept { 3250| 312k| limb carry = 0; 3251| 4.23M| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3251:26): [True: 3.92M, False: 312k] ------------------ 3252| 3.92M| vec[index] = scalar_mul(vec[index], y, carry); 3253| 3.92M| } 3254| 312k| if (carry != 0) { ------------------ | Branch (3254:7): [True: 278k, False: 33.4k] ------------------ 3255| 278k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 278k| { \ | | 355| 278k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 278k] | | ------------------ | | 356| 278k| return false; \ | | 357| 278k| } ------------------ 3256| 278k| } 3257| 312k| return true; 3258| 312k|} _ZNK3glz10fast_float8stackvecILt62EE3lenEv: 3039| 5.49M| constexpr size_t len() const noexcept { return length; } _ZN3glz10fast_float10scalar_mulEmmRm: 3196| 3.92M|scalar_mul(limb x, limb y, limb &carry) noexcept { 3197| 3.92M|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3198| 3.92M|#if defined(__SIZEOF_INT128__) 3199| | // GCC and clang both define it as an extension. 3200| 3.92M| __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry); 3201| 3.92M| carry = limb(z >> limb_bits); 3202| 3.92M| return limb(z); 3203| |#else 3204| | // fallback, no native 128-bit integer multiplication with carry. 3205| | // on msvc, this optimizes identically, somehow. 3206| | value128 z = full_multiplication(x, y); 3207| | bool overflow; 3208| | z.low = scalar_add(z.low, carry, overflow); 3209| | z.high += uint64_t(overflow); // cannot overflow 3210| | carry = z.high; 3211| | return z.low; 3212| |#endif 3213| |#else 3214| | uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry); 3215| | carry = limb(z >> limb_bits); 3216| | return limb(z); 3217| |#endif 3218| 3.92M|} _ZN3glz10fast_float8stackvecILt62EEixEm: 3017| 9.38M| GLZ_FASTFLOAT_CONSTEXPR14 limb &operator[](size_t index) noexcept { 3018| 9.38M| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 9.38M| { ((void)(x)); } ------------------ 3019| 9.38M| return data[index]; 3020| 9.38M| } _ZN3glz10fast_float8stackvecILt62EE8try_pushEm: 3052| 298k| GLZ_FASTFLOAT_CONSTEXPR14 bool try_push(limb value) noexcept { 3053| 298k| if (len() < capacity()) { ------------------ | Branch (3053:9): [True: 298k, False: 0] ------------------ 3054| 298k| push_unchecked(value); 3055| 298k| return true; 3056| 298k| } else { 3057| 0| return false; 3058| 0| } 3059| 298k| } _ZNK3glz10fast_float8stackvecILt62EE8capacityEv: 3043| 440k| constexpr size_t capacity() const noexcept { return size; } _ZN3glz10fast_float8stackvecILt62EE14push_uncheckedEm: 3046| 311k| GLZ_FASTFLOAT_CONSTEXPR14 void push_unchecked(limb value) noexcept { 3047| 311k| data[length] = value; 3048| 311k| length++; 3049| 311k| } _ZN3glz10fast_float6bigint3addEm: 3554| 203k| GLZ_FASTFLOAT_CONSTEXPR20 bool add(limb y) noexcept { return small_add(vec, y); } _ZN3glz10fast_float9small_addILt62EEEbRNS0_8stackvecIXT_EEEm: 3242| 203k|small_add(stackvec &vec, limb y) noexcept { 3243| 203k| return small_add_from(vec, y, 0); 3244| 203k|} _ZN3glz10fast_float14small_add_fromILt62EEEbRNS0_8stackvecIXT_EEEmm: 3224| 203k| size_t start) noexcept { 3225| 203k| size_t index = start; 3226| 203k| limb carry = y; 3227| 203k| bool overflow; 3228| 352k| while (carry != 0 && index < vec.len()) { ------------------ | Branch (3228:10): [True: 165k, False: 186k] | Branch (3228:24): [True: 149k, False: 16.3k] ------------------ 3229| 149k| vec[index] = scalar_add(vec[index], carry, overflow); 3230| 149k| carry = limb(overflow); 3231| 149k| index += 1; 3232| 149k| } 3233| 203k| if (carry != 0) { ------------------ | Branch (3233:7): [True: 16.3k, False: 186k] ------------------ 3234| 16.3k| GLZ_FASTFLOAT_TRY(vec.try_push(carry)); ------------------ | | 354| 16.3k| { \ | | 355| 16.3k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 16.3k] | | ------------------ | | 356| 16.3k| return false; \ | | 357| 16.3k| } ------------------ 3235| 16.3k| } 3236| 203k| return true; 3237| 203k|} _ZN3glz10fast_float10scalar_addEmmRb: 3176| 845k|scalar_add(limb x, limb y, bool &overflow) noexcept { 3177| 845k| limb z; 3178| |// gcc and clang 3179| 845k|#if defined(__has_builtin) 3180| 845k|#if __has_builtin(__builtin_add_overflow) 3181| 845k| if (!cpp20_and_in_constexpr()) { ------------------ | Branch (3181:7): [True: 845k, Folded] ------------------ 3182| 845k| overflow = __builtin_add_overflow(x, y, &z); 3183| 845k| return z; 3184| 845k| } 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| 845k|} _ZN3glz10fast_float12is_truncatedIcEEbPKT_S4_: 3795| 2.74k|is_truncated(UC const *first, UC const *last) noexcept { 3796| | // do 8-bit optimizations, can just compare to 8 literal 0s. 3797| 2.74k| uint64_t val; 3798| 177k| while (!cpp20_and_in_constexpr() && ------------------ | Branch (3798:10): [True: 177k, Folded] ------------------ 3799| 177k| std::distance(first, last) >= int_cmp_len()) { ------------------ | Branch (3799:10): [True: 176k, False: 1.58k] ------------------ 3800| 176k| ::memcpy(&val, first, sizeof(uint64_t)); 3801| 176k| if (val != int_cmp_zeros()) { ------------------ | Branch (3801:9): [True: 1.16k, False: 175k] ------------------ 3802| 1.16k| return true; 3803| 1.16k| } 3804| 175k| first += int_cmp_len(); 3805| 175k| } 3806| 4.03k| while (first != last) { ------------------ | Branch (3806:10): [True: 2.83k, False: 1.20k] ------------------ 3807| 2.83k| if (*first != UC('0')) { ------------------ | Branch (3807:9): [True: 378, False: 2.45k] ------------------ 3808| 378| return true; 3809| 378| } 3810| 2.45k| ++first; 3811| 2.45k| } 3812| 1.20k| return false; 3813| 1.58k|} _ZN3glz10fast_float15round_up_bigintERNS0_6bigintERm: 3848| 1.54k|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.54k| add_native(big, 10, 1); 3852| 1.54k| count++; 3853| 1.54k|} _ZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEi: 3942| 3.31k|positive_digit_comp(bigint &bigmant, int32_t exponent) noexcept { 3943| 3.31k| GLZ_FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent))); ------------------ | | 344| 3.31k| { ((void)(x)); } ------------------ 3944| 3.31k| adjusted_mantissa answer; 3945| 3.31k| bool truncated; 3946| 3.31k| answer.mantissa = bigmant.hi64(truncated); 3947| 3.31k| int bias = binary_format::mantissa_explicit_bits() - 3948| 3.31k| binary_format::minimum_exponent(); 3949| 3.31k| answer.power2 = bigmant.bit_length() - 64 + bias; 3950| | 3951| 3.31k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 3.31k| round_nearest_tie_even( 3953| 3.31k| a, shift, 3954| 3.31k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.31k| return is_above || (is_halfway && truncated) || 3956| 3.31k| (is_odd && is_halfway); 3957| 3.31k| }); 3958| 3.31k| }); 3959| | 3960| 3.31k| return answer; 3961| 3.31k|} _ZN3glz10fast_float6bigint5pow10Ej: 3591| 3.31k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow10(uint32_t exp) noexcept { 3592| 3.31k| GLZ_FASTFLOAT_TRY(pow5(exp)); ------------------ | | 354| 3.31k| { \ | | 355| 3.31k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 3.31k] | | ------------------ | | 356| 3.31k| return false; \ | | 357| 3.31k| } ------------------ 3593| 3.31k| return pow2(exp); 3594| 3.31k| } _ZN3glz10fast_float6bigint4pow5Ej: 3560| 16.2k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow5(uint32_t exp) noexcept { 3561| | // multiply by a power of 5 3562| 16.2k| size_t large_length = sizeof(large_power_of_5) / sizeof(limb); 3563| 16.2k| limb_span large = limb_span(large_power_of_5, large_length); 3564| 31.2k| while (exp >= large_step) { ------------------ | Branch (3564:12): [True: 14.9k, False: 16.2k] ------------------ 3565| 14.9k| GLZ_FASTFLOAT_TRY(large_mul(vec, large)); ------------------ | | 354| 14.9k| { \ | | 355| 14.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.9k] | | ------------------ | | 356| 14.9k| return false; \ | | 357| 14.9k| } ------------------ 3566| 14.9k| exp -= large_step; 3567| 14.9k| } 3568| 16.2k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3569| 16.2k| uint32_t small_step = 27; 3570| 16.2k| limb max_native = 7450580596923828125UL; 3571| |#else 3572| | uint32_t small_step = 13; 3573| | limb max_native = 1220703125U; 3574| |#endif 3575| 37.8k| while (exp >= small_step) { ------------------ | Branch (3575:12): [True: 21.5k, False: 16.2k] ------------------ 3576| 21.5k| GLZ_FASTFLOAT_TRY(small_mul(vec, max_native)); ------------------ | | 354| 21.5k| { \ | | 355| 21.5k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 21.5k] | | ------------------ | | 356| 21.5k| return false; \ | | 357| 21.5k| } ------------------ 3577| 21.5k| exp -= small_step; 3578| 21.5k| } 3579| 16.2k| if (exp != 0) { ------------------ | Branch (3579:9): [True: 12.5k, False: 3.71k] ------------------ 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| 12.5k| GLZ_FASTFLOAT_TRY(small_mul( ------------------ | | 354| 12.5k| { \ | | 355| 12.5k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 12.5k] | | ------------------ | | 356| 12.5k| return false; \ | | 357| 12.5k| } ------------------ 3584| 12.5k| vec, limb(((void)small_power_of_5[0], small_power_of_5[exp])))); 3585| 12.5k| } 3586| | 3587| 16.2k| return true; 3588| 16.2k| } _ZN3glz10fast_float4spanImEC2EPKmm: 436| 106k| constexpr span(T const *_ptr, size_t _length) : ptr(_ptr), length(_length) {} _ZN3glz10fast_float9large_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3329| 14.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool large_mul(stackvec &x, limb_span y) noexcept { 3330| 14.9k| if (y.len() == 1) { ------------------ | Branch (3330:7): [True: 0, False: 14.9k] ------------------ 3331| 0| GLZ_FASTFLOAT_TRY(small_mul(x, y[0])); ------------------ | | 354| 0| { \ | | 355| 0| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 0] | | ------------------ | | 356| 0| return false; \ | | 357| 0| } ------------------ 3332| 14.9k| } else { 3333| 14.9k| GLZ_FASTFLOAT_TRY(long_mul(x, y)); ------------------ | | 354| 14.9k| { \ | | 355| 14.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.9k] | | ------------------ | | 356| 14.9k| return false; \ | | 357| 14.9k| } ------------------ 3334| 14.9k| } 3335| 14.9k| return true; 3336| 14.9k|} _ZNK3glz10fast_float4spanImE3lenEv: 440| 1.01M| constexpr size_t len() const noexcept { return length; } _ZNK3glz10fast_float4spanImEixEm: 442| 579k| GLZ_FASTFLOAT_CONSTEXPR14 const T &operator[](size_t index) const noexcept { 443| 579k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 579k| { ((void)(x)); } ------------------ 444| 579k| return ptr[index]; 445| 579k| } _ZN3glz10fast_float8long_mulILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEE: 3301| 14.9k|GLZ_FASTFLOAT_CONSTEXPR20 bool long_mul(stackvec &x, limb_span y) noexcept { 3302| 14.9k| limb_span xs = limb_span(x.data, x.len()); 3303| 14.9k| stackvec z(xs); 3304| 14.9k| limb_span zs = limb_span(z.data, z.len()); 3305| | 3306| 14.9k| if (y.len() != 0) { ------------------ | Branch (3306:7): [True: 14.9k, False: 0] ------------------ 3307| 14.9k| limb y0 = y[0]; 3308| 14.9k| GLZ_FASTFLOAT_TRY(small_mul(x, y0)); ------------------ | | 354| 14.9k| { \ | | 355| 14.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 14.9k] | | ------------------ | | 356| 14.9k| return false; \ | | 357| 14.9k| } ------------------ 3309| 74.9k| for (size_t index = 1; index < y.len(); index++) { ------------------ | Branch (3309:28): [True: 59.9k, False: 14.9k] ------------------ 3310| 59.9k| limb yi = y[index]; 3311| 59.9k| stackvec zi; 3312| 59.9k| if (yi != 0) { ------------------ | Branch (3312:11): [True: 59.9k, False: 0] ------------------ 3313| | // re-use the same buffer throughout 3314| 59.9k| zi.set_len(0); 3315| 59.9k| GLZ_FASTFLOAT_TRY(zi.try_extend(zs)); ------------------ | | 354| 59.9k| { \ | | 355| 59.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 59.9k] | | ------------------ | | 356| 59.9k| return false; \ | | 357| 59.9k| } ------------------ 3316| 59.9k| GLZ_FASTFLOAT_TRY(small_mul(zi, yi)); ------------------ | | 354| 59.9k| { \ | | 355| 59.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 59.9k] | | ------------------ | | 356| 59.9k| return false; \ | | 357| 59.9k| } ------------------ 3317| 59.9k| limb_span zis = limb_span(zi.data, zi.len()); 3318| 59.9k| GLZ_FASTFLOAT_TRY(large_add_from(x, zis, index)); ------------------ | | 354| 59.9k| { \ | | 355| 59.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 59.9k] | | ------------------ | | 356| 59.9k| return false; \ | | 357| 59.9k| } ------------------ 3319| 59.9k| } 3320| 59.9k| } 3321| 14.9k| } 3322| | 3323| 14.9k| x.normalize(); 3324| 14.9k| return true; 3325| 14.9k|} _ZN3glz10fast_float8stackvecILt62EEC2ENS0_4spanImEE: 3013| 14.9k| GLZ_FASTFLOAT_CONSTEXPR20 stackvec(limb_span s) { 3014| 14.9k| GLZ_FASTFLOAT_ASSERT(try_extend(s)); ------------------ | | 344| 14.9k| { ((void)(x)); } ------------------ 3015| 14.9k| } _ZN3glz10fast_float8stackvecILt62EE7set_lenEm: 3035| 201k| GLZ_FASTFLOAT_CONSTEXPR14 void set_len(size_t len) noexcept { 3036| 201k| length = uint16_t(len); 3037| 201k| } _ZN3glz10fast_float8stackvecILt62EE10try_extendENS0_4spanImEE: 3069| 74.9k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_extend(limb_span s) noexcept { 3070| 74.9k| if (len() + s.len() <= capacity()) { ------------------ | Branch (3070:9): [True: 74.9k, False: 0] ------------------ 3071| 74.9k| extend_unchecked(s); 3072| 74.9k| return true; 3073| 74.9k| } else { 3074| 0| return false; 3075| 0| } 3076| 74.9k| } _ZN3glz10fast_float8stackvecILt62EE16extend_uncheckedENS0_4spanImEE: 3062| 74.9k| GLZ_FASTFLOAT_CONSTEXPR20 void extend_unchecked(limb_span s) noexcept { 3063| 74.9k| limb *ptr = data + length; 3064| 74.9k| std::copy_n(s.ptr, s.len(), ptr); 3065| 74.9k| set_len(len() + s.len()); 3066| 74.9k| } _ZN3glz10fast_float14large_add_fromILt62EEEbRNS0_8stackvecIXT_EEENS0_4spanImEEm: 3264| 59.9k| 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| 59.9k| if (x.len() < start || y.len() > x.len() - start) { ------------------ | Branch (3267:7): [True: 0, False: 59.9k] | Branch (3267:26): [True: 59.9k, False: 33] ------------------ 3268| 59.9k| GLZ_FASTFLOAT_TRY(x.try_resize(y.len() + start, 0)); ------------------ | | 354| 59.9k| { \ | | 355| 59.9k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 59.9k] | | ------------------ | | 356| 59.9k| return false; \ | | 357| 59.9k| } ------------------ 3269| 59.9k| } 3270| | 3271| 59.9k| bool carry = false; 3272| 564k| for (size_t index = 0; index < y.len(); index++) { ------------------ | Branch (3272:26): [True: 504k, False: 59.9k] ------------------ 3273| 504k| limb xi = x[index + start]; 3274| 504k| limb yi = y[index]; 3275| 504k| bool c1 = false; 3276| 504k| bool c2 = false; 3277| 504k| xi = scalar_add(xi, yi, c1); 3278| 504k| if (carry) { ------------------ | Branch (3278:9): [True: 191k, False: 312k] ------------------ 3279| 191k| xi = scalar_add(xi, 1, c2); 3280| 191k| } 3281| 504k| x[index + start] = xi; 3282| 504k| carry = c1 | c2; 3283| 504k| } 3284| | 3285| | // handle overflow 3286| 59.9k| if (carry) { ------------------ | Branch (3286:7): [True: 0, False: 59.9k] ------------------ 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| 59.9k| return true; 3290| 59.9k|} _ZN3glz10fast_float8stackvecILt62EE10try_resizeEmm: 3095| 59.9k| GLZ_FASTFLOAT_CONSTEXPR20 bool try_resize(size_t new_len, limb value) noexcept { 3096| 59.9k| if (new_len > capacity()) { ------------------ | Branch (3096:9): [True: 0, False: 59.9k] ------------------ 3097| 0| return false; 3098| 59.9k| } else { 3099| 59.9k| resize_unchecked(new_len, value); 3100| 59.9k| return true; 3101| 59.9k| } 3102| 59.9k| } _ZN3glz10fast_float8stackvecILt62EE16resize_uncheckedEmm: 3082| 59.9k| void resize_unchecked(size_t new_len, limb value) noexcept { 3083| 59.9k| if (new_len > len()) { ------------------ | Branch (3083:9): [True: 59.9k, False: 0] ------------------ 3084| 59.9k| size_t count = new_len - len(); 3085| 59.9k| limb *first = data + len(); 3086| 59.9k| limb *last = first + count; 3087| 59.9k| ::std::fill(first, last, value); 3088| 59.9k| set_len(new_len); 3089| 59.9k| } else { 3090| 0| set_len(new_len); 3091| 0| } 3092| 59.9k| } _ZN3glz10fast_float8stackvecILt62EE9normalizeEv: 3118| 27.9k| GLZ_FASTFLOAT_CONSTEXPR14 void normalize() noexcept { 3119| 27.9k| while (len() > 0 && rindex(0) == 0) { ------------------ | Branch (3119:12): [True: 27.9k, False: 0] | Branch (3119:25): [True: 0, False: 27.9k] ------------------ 3120| 0| length--; 3121| 0| } 3122| 27.9k| } _ZNK3glz10fast_float8stackvecILt62EE6rindexEm: 3028| 38.4k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &rindex(size_t index) const noexcept { 3029| 38.4k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 38.4k| { ((void)(x)); } ------------------ 3030| 38.4k| size_t rindex = length - index - 1; 3031| 38.4k| return data[rindex]; 3032| 38.4k| } _ZN3glz10fast_float6bigint4pow2Ej: 3557| 16.0k| GLZ_FASTFLOAT_CONSTEXPR20 bool pow2(uint32_t exp) noexcept { return shl(exp); } _ZN3glz10fast_float6bigint3shlEm: 3519| 16.0k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl(size_t n) noexcept { 3520| 16.0k| size_t rem = n % limb_bits; 3521| 16.0k| size_t div = n / limb_bits; 3522| 16.0k| if (rem != 0) { ------------------ | Branch (3522:9): [True: 12.7k, False: 3.31k] ------------------ 3523| 12.7k| GLZ_FASTFLOAT_TRY(shl_bits(rem)); ------------------ | | 354| 12.7k| { \ | | 355| 12.7k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 12.7k] | | ------------------ | | 356| 12.7k| return false; \ | | 357| 12.7k| } ------------------ 3524| 12.7k| } 3525| 16.0k| if (div != 0) { ------------------ | Branch (3525:9): [True: 7.06k, False: 8.98k] ------------------ 3526| 7.06k| GLZ_FASTFLOAT_TRY(shl_limbs(div)); ------------------ | | 354| 7.06k| { \ | | 355| 7.06k| if (!(x)) \ | | ------------------ | | | Branch (355:9): [True: 0, False: 7.06k] | | ------------------ | | 356| 7.06k| return false; \ | | 357| 7.06k| } ------------------ 3527| 7.06k| } 3528| 16.0k| return true; 3529| 16.0k| } _ZN3glz10fast_float6bigint8shl_bitsEm: 3472| 12.7k| 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| 12.7k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 12.7k| { ((void)(x)); } ------------------ 3479| 12.7k| GLZ_FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8); ------------------ | | 349| 12.7k| { ((void)(x)); } ------------------ 3480| | 3481| 12.7k| size_t shl = n; 3482| 12.7k| size_t shr = limb_bits - shl; 3483| 12.7k| limb prev = 0; 3484| 128k| for (size_t index = 0; index < vec.len(); index++) { ------------------ | Branch (3484:28): [True: 115k, False: 12.7k] ------------------ 3485| 115k| limb xi = vec[index]; 3486| 115k| vec[index] = (xi << shl) | (prev >> shr); 3487| 115k| prev = xi; 3488| 115k| } 3489| | 3490| 12.7k| limb carry = prev >> shr; 3491| 12.7k| if (carry != 0) { ------------------ | Branch (3491:9): [True: 3.55k, False: 9.18k] ------------------ 3492| 3.55k| return vec.try_push(carry); 3493| 3.55k| } 3494| 9.18k| return true; 3495| 12.7k| } _ZN3glz10fast_float6bigint9shl_limbsEm: 3498| 7.06k| GLZ_FASTFLOAT_CONSTEXPR20 bool shl_limbs(size_t n) noexcept { 3499| 7.06k| GLZ_FASTFLOAT_DEBUG_ASSERT(n != 0); ------------------ | | 349| 7.06k| { ((void)(x)); } ------------------ 3500| 7.06k| if (n + vec.len() > vec.capacity()) { ------------------ | Branch (3500:9): [True: 0, False: 7.06k] ------------------ 3501| 0| return false; 3502| 7.06k| } else if (!vec.is_empty()) { ------------------ | Branch (3502:16): [True: 7.06k, False: 0] ------------------ 3503| | // move limbs 3504| 7.06k| limb *dst = vec.data + n; 3505| 7.06k| limb const *src = vec.data; 3506| 7.06k| std::copy_backward(src, src + vec.len(), dst + vec.len()); 3507| | // fill in empty limbs 3508| 7.06k| limb *first = vec.data; 3509| 7.06k| limb *last = first + n; 3510| 7.06k| ::std::fill(first, last, 0); 3511| 7.06k| vec.set_len(n + vec.len()); 3512| 7.06k| return true; 3513| 7.06k| } else { 3514| 0| return true; 3515| 0| } 3516| 7.06k| } _ZNK3glz10fast_float8stackvecILt62EE8is_emptyEv: 3041| 10.3k| constexpr bool is_empty() const noexcept { return length == 0; } _ZNK3glz10fast_float6bigint4hi64ERb: 3418| 3.31k| GLZ_FASTFLOAT_CONSTEXPR20 uint64_t hi64(bool &truncated) const noexcept { 3419| 3.31k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3420| 3.31k| if (vec.len() == 0) { ------------------ | Branch (3420:9): [True: 0, False: 3.31k] ------------------ 3421| 0| return empty_hi64(truncated); 3422| 3.31k| } else if (vec.len() == 1) { ------------------ | Branch (3422:16): [True: 686, False: 2.62k] ------------------ 3423| 686| return uint64_hi64(vec.rindex(0), truncated); 3424| 2.62k| } else { 3425| 2.62k| uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated); 3426| 2.62k| truncated |= vec.nonzero(2); 3427| 2.62k| return result; 3428| 2.62k| } 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.31k| } _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| 2.62k|uint64_hi64(uint64_t r0, uint64_t r1, bool &truncated) noexcept { 3140| 2.62k| int shl = leading_zeroes(r0); 3141| 2.62k| if (shl == 0) { ------------------ | Branch (3141:7): [True: 613, False: 2.01k] ------------------ 3142| 613| truncated = r1 != 0; 3143| 613| return r0; 3144| 2.01k| } else { 3145| 2.01k| int shr = 64 - shl; 3146| 2.01k| truncated = (r1 << shl) != 0; 3147| 2.01k| return (r0 << shl) | (r1 >> shr); 3148| 2.01k| } 3149| 2.62k|} _ZNK3glz10fast_float8stackvecILt62EE7nonzeroEm: 3107| 2.62k| GLZ_FASTFLOAT_CONSTEXPR14 bool nonzero(size_t index) const noexcept { 3108| 2.64k| while (index < len()) { ------------------ | Branch (3108:12): [True: 1.26k, False: 1.37k] ------------------ 3109| 1.26k| if (rindex(index) != 0) { ------------------ | Branch (3109:11): [True: 1.25k, False: 12] ------------------ 3110| 1.25k| return true; 3111| 1.25k| } 3112| 12| index++; 3113| 12| } 3114| 1.37k| return false; 3115| 2.62k| } _ZNK3glz10fast_float6bigint10bit_lengthEv: 3547| 3.31k| GLZ_FASTFLOAT_CONSTEXPR20 int bit_length() const noexcept { 3548| 3.31k| int lz = ctlz(); 3549| 3.31k| return int(limb_bits * vec.len()) - lz; 3550| 3.31k| } _ZNK3glz10fast_float6bigint4ctlzEv: 3532| 3.31k| GLZ_FASTFLOAT_CONSTEXPR20 int ctlz() const noexcept { 3533| 3.31k| if (vec.is_empty()) { ------------------ | Branch (3533:9): [True: 0, False: 3.31k] ------------------ 3534| 0| return 0; 3535| 3.31k| } else { 3536| 3.31k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3537| 3.31k| 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.31k| } 3544| 3.31k| } _ZN3glz10fast_float5roundIdZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiEUlRS3_iE_EEvS6_T0_: 3707| 3.31k| callback cb) noexcept { 3708| 3.31k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 3.31k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 0, False: 3.31k] ------------------ 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.31k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 3.31k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 426, False: 2.88k] ------------------ 3726| 3.31k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 426| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 426| am.power2++; 3729| 426| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 3.31k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 3.31k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 3.31k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 3.31k|} _ZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_i: 3951| 3.31k| round(answer, [truncated](adjusted_mantissa &a, int32_t shift) { 3952| 3.31k| round_nearest_tie_even( 3953| 3.31k| a, shift, 3954| 3.31k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.31k| return is_above || (is_halfway && truncated) || 3956| 3.31k| (is_odd && is_halfway); 3957| 3.31k| }); 3958| 3.31k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS3_iE_clES6_iEUlbbbE_EEvS6_iT_: 3742| 3.31k| callback cb) noexcept { 3743| 3.31k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 3.31k] ------------------ 3744| 3.31k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 3.31k] ------------------ 3745| 3.31k| uint64_t truncated_bits = am.mantissa & mask; 3746| 3.31k| bool is_above = truncated_bits > halfway; 3747| 3.31k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 3.31k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 3.31k] ------------------ 3751| 0| am.mantissa = 0; 3752| 3.31k| } else { 3753| 3.31k| am.mantissa >>= shift; 3754| 3.31k| } 3755| 3.31k| am.power2 += shift; 3756| | 3757| 3.31k| bool is_odd = (am.mantissa & 1) == 1; 3758| 3.31k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 3.31k|} _ZZZN3glz10fast_float19positive_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintEiENKUlRS2_iE_clES5_iENKUlbbbE_clEbbb: 3954| 3.31k| [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool { 3955| 3.31k| return is_above || (is_halfway && truncated) || ------------------ | Branch (3955:18): [True: 702, False: 2.61k] | Branch (3955:31): [True: 1.22k, False: 1.39k] | Branch (3955:45): [True: 993, False: 230] ------------------ 3956| 1.62k| (is_odd && is_halfway); ------------------ | Branch (3956:19): [True: 761, False: 859] | Branch (3956:29): [True: 193, False: 568] ------------------ 3957| 3.31k| }); _ZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_i: 3970| 12.9k| bigint &bigmant, adjusted_mantissa am, int32_t exponent) noexcept { 3971| 12.9k| bigint &real_digits = bigmant; 3972| 12.9k| int32_t real_exp = exponent; 3973| | 3974| | // get the value of `b`, rounded down, and get a bigint representation of b+h 3975| 12.9k| adjusted_mantissa am_b = am; 3976| | // gcc7 buf: use a lambda to remove the noexcept qualifier bug with 3977| | // -Wnoexcept-type. 3978| 12.9k| round(am_b, 3979| 12.9k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); 3980| 12.9k| T b; 3981| 12.9k| to_float(false, am_b, b); 3982| 12.9k| adjusted_mantissa theor = to_extended_halfway(b); 3983| 12.9k| bigint theor_digits(theor.mantissa); 3984| 12.9k| int32_t theor_exp = theor.power2; 3985| | 3986| | // scale real digits and theor digits to be same power. 3987| 12.9k| int32_t pow2_exp = theor_exp - real_exp; 3988| 12.9k| uint32_t pow5_exp = uint32_t(-real_exp); 3989| 12.9k| if (pow5_exp != 0) { ------------------ | Branch (3989:7): [True: 12.9k, False: 0] ------------------ 3990| 12.9k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp)); ------------------ | | 344| 12.9k| { ((void)(x)); } ------------------ 3991| 12.9k| } 3992| 12.9k| if (pow2_exp > 0) { ------------------ | Branch (3992:7): [True: 9.60k, False: 3.36k] ------------------ 3993| 9.60k| GLZ_FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp))); ------------------ | | 344| 9.60k| { ((void)(x)); } ------------------ 3994| 9.60k| } else if (pow2_exp < 0) { ------------------ | Branch (3994:14): [True: 3.13k, False: 239] ------------------ 3995| 3.13k| GLZ_FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp))); ------------------ | | 344| 3.13k| { ((void)(x)); } ------------------ 3996| 3.13k| } 3997| | 3998| | // compare digits, and use it to director rounding 3999| 12.9k| int ord = real_digits.compare(theor_digits); 4000| 12.9k| adjusted_mantissa answer = am; 4001| 12.9k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 12.9k| round_nearest_tie_even( 4003| 12.9k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 12.9k| (void)_; // not needed, since we've done our comparison 4005| 12.9k| (void)__; // not needed, since we've done our comparison 4006| 12.9k| if (ord > 0) { 4007| 12.9k| return true; 4008| 12.9k| } else if (ord < 0) { 4009| 12.9k| return false; 4010| 12.9k| } else { 4011| 12.9k| return is_odd; 4012| 12.9k| } 4013| 12.9k| }); 4014| 12.9k| }); 4015| | 4016| 12.9k| return answer; 4017| 12.9k|} _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE_EEvS6_T0_: 3707| 12.9k| callback cb) noexcept { 3708| 12.9k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 12.9k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 8, False: 12.9k] ------------------ 3710| | // have a denormal float 3711| 8| int32_t shift = -am.power2 + 1; 3712| 8| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 8| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 8, False: 0] ------------------ 3715| 8| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 8| ? 0 3717| 8| : 1; 3718| 8| return; 3719| 8| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 12.9k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 12.9k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 0, False: 12.9k] ------------------ 3726| 12.9k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 0| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 0| am.power2++; 3729| 0| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 12.9k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 12.9k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 12.9k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 12.9k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE_clES5_i: 3979| 12.9k| [](adjusted_mantissa &a, int32_t shift) { round_down(a, shift); }); _ZN3glz10fast_float10round_downERNS0_17adjusted_mantissaEi: 3762| 12.9k|round_down(adjusted_mantissa &am, int32_t shift) noexcept { 3763| 12.9k| if (shift == 64) { ------------------ | Branch (3763:7): [True: 0, False: 12.9k] ------------------ 3764| 0| am.mantissa = 0; 3765| 12.9k| } else { 3766| 12.9k| am.mantissa >>= shift; 3767| 12.9k| } 3768| 12.9k| am.power2 += shift; 3769| 12.9k|} _ZN3glz10fast_float19to_extended_halfwayIdEENS0_17adjusted_mantissaET_: 3696| 12.9k|to_extended_halfway(T value) noexcept { 3697| 12.9k| adjusted_mantissa am = to_extended(value); 3698| 12.9k| am.mantissa <<= 1; 3699| 12.9k| am.mantissa += 1; 3700| 12.9k| am.power2 -= 1; 3701| 12.9k| return am; 3702| 12.9k|} _ZN3glz10fast_float11to_extendedIdEENS0_17adjusted_mantissaET_: 3661| 12.9k|to_extended(T value) noexcept { 3662| 12.9k| using equiv_uint = equiv_uint_t; 3663| 12.9k| constexpr equiv_uint exponent_mask = binary_format::exponent_mask(); 3664| 12.9k| constexpr equiv_uint mantissa_mask = binary_format::mantissa_mask(); 3665| 12.9k| constexpr equiv_uint hidden_bit_mask = binary_format::hidden_bit_mask(); 3666| | 3667| 12.9k| adjusted_mantissa am; 3668| 12.9k| int32_t bias = binary_format::mantissa_explicit_bits() - 3669| 12.9k| binary_format::minimum_exponent(); 3670| 12.9k| equiv_uint bits; 3671| 12.9k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 3672| 12.9k| bits = std::bit_cast(value); 3673| |#else 3674| | ::memcpy(&bits, &value, sizeof(T)); 3675| |#endif 3676| 12.9k| if ((bits & exponent_mask) == 0) { ------------------ | Branch (3676:7): [True: 8, False: 12.9k] ------------------ 3677| | // denormal 3678| 8| am.power2 = 1 - bias; 3679| 8| am.mantissa = bits & mantissa_mask; 3680| 12.9k| } else { 3681| | // normal 3682| 12.9k| am.power2 = int32_t((bits & exponent_mask) >> 3683| 12.9k| binary_format::mantissa_explicit_bits()); 3684| 12.9k| am.power2 -= bias; 3685| 12.9k| am.mantissa = (bits & mantissa_mask) | hidden_bit_mask; 3686| 12.9k| } 3687| | 3688| 12.9k| return am; 3689| 12.9k|} _ZN3glz10fast_float6bigintC2Em: 3406| 12.9k| GLZ_FASTFLOAT_CONSTEXPR20 bigint(uint64_t value) : vec() { 3407| 12.9k|#ifdef GLZ_FASTFLOAT_64BIT_LIMB 3408| 12.9k| vec.push_unchecked(value); 3409| |#else 3410| | vec.push_unchecked(uint32_t(value)); 3411| | vec.push_unchecked(uint32_t(value >> 32)); 3412| |#endif 3413| 12.9k| vec.normalize(); 3414| 12.9k| } _ZNK3glz10fast_float6bigint7compareERKS1_: 3451| 12.9k| GLZ_FASTFLOAT_CONSTEXPR20 int compare(bigint const &other) const noexcept { 3452| 12.9k| if (vec.len() > other.vec.len()) { ------------------ | Branch (3452:9): [True: 0, False: 12.9k] ------------------ 3453| 0| return 1; 3454| 12.9k| } else if (vec.len() < other.vec.len()) { ------------------ | Branch (3454:16): [True: 0, False: 12.9k] ------------------ 3455| 0| return -1; 3456| 12.9k| } else { 3457| 26.0k| for (size_t index = vec.len(); index > 0; index--) { ------------------ | Branch (3457:38): [True: 25.7k, False: 268] ------------------ 3458| 25.7k| limb xi = vec[index - 1]; 3459| 25.7k| limb yi = other.vec[index - 1]; 3460| 25.7k| if (xi > yi) { ------------------ | Branch (3460:13): [True: 8.79k, False: 16.9k] ------------------ 3461| 8.79k| return 1; 3462| 16.9k| } else if (xi < yi) { ------------------ | Branch (3462:20): [True: 3.91k, False: 13.0k] ------------------ 3463| 3.91k| return -1; 3464| 3.91k| } 3465| 25.7k| } 3466| 268| return 0; 3467| 12.9k| } 3468| 12.9k| } _ZNK3glz10fast_float8stackvecILt62EEixEm: 3022| 51.5k| GLZ_FASTFLOAT_CONSTEXPR14 const limb &operator[](size_t index) const noexcept { 3023| 51.5k| GLZ_FASTFLOAT_DEBUG_ASSERT(index < length); ------------------ | | 349| 51.5k| { ((void)(x)); } ------------------ 3024| 51.5k| return data[index]; 3025| 51.5k| } _ZN3glz10fast_float5roundIdZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iEUlRS3_iE0_EEvS6_T0_: 3707| 12.9k| callback cb) noexcept { 3708| 12.9k| int32_t mantissa_shift = 64 - binary_format::mantissa_explicit_bits() - 1; 3709| 12.9k| if (-am.power2 >= mantissa_shift) { ------------------ | Branch (3709:7): [True: 8, False: 12.9k] ------------------ 3710| | // have a denormal float 3711| 8| int32_t shift = -am.power2 + 1; 3712| 8| cb(am, (std::min)(shift, 64)); 3713| | // check for round-up: if rounding-nearest carried us to the hidden bit. 3714| 8| am.power2 = (am.mantissa < ------------------ | Branch (3714:17): [True: 8, False: 0] ------------------ 3715| 8| (uint64_t(1) << binary_format::mantissa_explicit_bits())) 3716| 8| ? 0 3717| 8| : 1; 3718| 8| return; 3719| 8| } 3720| | 3721| | // have a normal float, use the default shift. 3722| 12.9k| cb(am, mantissa_shift); 3723| | 3724| | // check for carry 3725| 12.9k| if (am.mantissa >= ------------------ | Branch (3725:7): [True: 279, False: 12.6k] ------------------ 3726| 12.9k| (uint64_t(2) << binary_format::mantissa_explicit_bits())) { 3727| 279| am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); 3728| 279| am.power2++; 3729| 279| } 3730| | 3731| | // check for infinite: we could have carried to an infinite power 3732| 12.9k| am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); 3733| 12.9k| if (am.power2 >= binary_format::infinite_power()) { ------------------ | Branch (3733:7): [True: 0, False: 12.9k] ------------------ 3734| 0| am.power2 = binary_format::infinite_power(); 3735| 0| am.mantissa = 0; 3736| 0| } 3737| 12.9k|} _ZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_i: 4001| 12.9k| round(answer, [ord](adjusted_mantissa &a, int32_t shift) { 4002| 12.9k| round_nearest_tie_even( 4003| 12.9k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 12.9k| (void)_; // not needed, since we've done our comparison 4005| 12.9k| (void)__; // not needed, since we've done our comparison 4006| 12.9k| if (ord > 0) { 4007| 12.9k| return true; 4008| 12.9k| } else if (ord < 0) { 4009| 12.9k| return false; 4010| 12.9k| } else { 4011| 12.9k| return is_odd; 4012| 12.9k| } 4013| 12.9k| }); 4014| 12.9k| }); _ZN3glz10fast_float22round_nearest_tie_evenIZZNS0_19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES3_iENKUlRS3_iE0_clES6_iEUlbbbE_EEvS6_iT_: 3742| 12.9k| callback cb) noexcept { 3743| 12.9k| uint64_t const mask = (shift == 64) ? UINT64_MAX : (uint64_t(1) << shift) - 1; ------------------ | Branch (3743:25): [True: 0, False: 12.9k] ------------------ 3744| 12.9k| uint64_t const halfway = (shift == 0) ? 0 : uint64_t(1) << (shift - 1); ------------------ | Branch (3744:28): [True: 0, False: 12.9k] ------------------ 3745| 12.9k| uint64_t truncated_bits = am.mantissa & mask; 3746| 12.9k| bool is_above = truncated_bits > halfway; 3747| 12.9k| bool is_halfway = truncated_bits == halfway; 3748| | 3749| | // shift digits into position 3750| 12.9k| if (shift == 64) { ------------------ | Branch (3750:7): [True: 0, False: 12.9k] ------------------ 3751| 0| am.mantissa = 0; 3752| 12.9k| } else { 3753| 12.9k| am.mantissa >>= shift; 3754| 12.9k| } 3755| 12.9k| am.power2 += shift; 3756| | 3757| 12.9k| bool is_odd = (am.mantissa & 1) == 1; 3758| 12.9k| am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above)); 3759| 12.9k|} _ZZZN3glz10fast_float19negative_digit_compIdEENS0_17adjusted_mantissaERNS0_6bigintES2_iENKUlRS2_iE0_clES5_iENKUlbbbE_clEbbb: 4003| 12.9k| a, shift, [ord](bool is_odd, bool _, bool __) -> bool { 4004| 12.9k| (void)_; // not needed, since we've done our comparison 4005| 12.9k| (void)__; // not needed, since we've done our comparison 4006| 12.9k| if (ord > 0) { ------------------ | Branch (4006:15): [True: 8.79k, False: 4.17k] ------------------ 4007| 8.79k| return true; 4008| 8.79k| } else if (ord < 0) { ------------------ | Branch (4008:22): [True: 3.91k, False: 268] ------------------ 4009| 3.91k| return false; 4010| 3.91k| } else { 4011| 268| return is_odd; 4012| 268| } 4013| 12.9k| }); _ZN3glz10fast_float8to_floatIdEEvbNS0_17adjusted_mantissaERT_: 1131| 49.0k|to_float(bool negative, adjusted_mantissa am, T &value) { 1132| 49.0k| using equiv_uint = equiv_uint_t; 1133| 49.0k| equiv_uint word = equiv_uint(am.mantissa); 1134| 49.0k| word = equiv_uint(word | equiv_uint(am.power2) 1135| 49.0k| << binary_format::mantissa_explicit_bits()); 1136| 49.0k| word = 1137| 49.0k| equiv_uint(word | equiv_uint(negative) << binary_format::sign_index()); 1138| 49.0k|#if GLZ_FASTFLOAT_HAS_BIT_CAST 1139| 49.0k| value = std::bit_cast(word); 1140| |#else 1141| | ::memcpy(&value, &word, sizeof(T)); 1142| |#endif 1143| 49.0k|} _ZN3glz10fast_float13binary_formatIdE10sign_indexEv: 758| 49.0k|template <> inline constexpr int binary_format::sign_index() { 759| 49.0k| return 63; 760| 49.0k|} _ZN3glz10fast_float13binary_formatIdE14infinite_powerEv: 750| 129k|template <> inline constexpr int binary_format::infinite_power() { 751| 129k| return 0x7FF; 752| 129k|} repe_registry.cpp:_ZN3glz8for_eachILm5EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 24| 304k| { 25| 304k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 304k| else { 47| 304k| [&](std::index_sequence) { 48| 304k| (void)(lambda.template operator()(), ...); 49| 304k| }(std::make_index_sequence{}); 50| 304k| } 51| 304k| } 52| 304k| } repe_registry.cpp:_ZZN3glz8for_eachILm5EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz10member_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_ENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4EEEEDaSF_: 47| 304k| [&](std::index_sequence) { 48| 304k| (void)(lambda.template operator()(), ...); 49| 304k| }(std::make_index_sequence{}); _ZN3glz8for_eachILm2EZNS_2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEES3_RNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSK_: 24| 112| { 25| 112| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 112| else if constexpr (N == 2) { 32| 112| lambda.template operator()<0>(); 33| 112| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 112| } 52| 112| } _ZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_m: 81| 63.8k| { 82| 63.8k| if constexpr (N > 0) { 83| | // Explicit sizes for small N to help the compiler and make debugging easier 84| | if constexpr (N == 1) { 85| | (void)index; 86| | (void)(lambda.template operator()<0>()); 87| | } 88| | else if constexpr (N == 2) { 89| | switch (index) { 90| | case 0: 91| | lambda.template operator()<0>(); 92| | break; 93| | case 1: 94| | lambda.template operator()<1>(); 95| | break; 96| | default: 97| | std::unreachable(); 98| | } 99| | } 100| | else if constexpr (N == 3) { 101| | switch (index) { 102| | case 0: 103| | lambda.template operator()<0>(); 104| | break; 105| | case 1: 106| | lambda.template operator()<1>(); 107| | break; 108| | case 2: 109| | lambda.template operator()<2>(); 110| | break; 111| | default: 112| | std::unreachable(); 113| | } 114| | } 115| | else if constexpr (N == 4) { 116| | switch (index) { 117| | case 0: 118| | lambda.template operator()<0>(); 119| | break; 120| | case 1: 121| | lambda.template operator()<1>(); 122| | break; 123| | case 2: 124| | lambda.template operator()<2>(); 125| | break; 126| | case 3: 127| | lambda.template operator()<3>(); 128| | break; 129| | default: 130| | std::unreachable(); 131| | } 132| | } 133| | else if constexpr (N == 5) { 134| | switch (index) { 135| | case 0: 136| | lambda.template operator()<0>(); 137| | break; 138| | case 1: 139| | lambda.template operator()<1>(); 140| | break; 141| | case 2: 142| | lambda.template operator()<2>(); 143| | break; 144| | case 3: 145| | lambda.template operator()<3>(); 146| | break; 147| | case 4: 148| | lambda.template operator()<4>(); 149| | break; 150| | default: 151| | std::unreachable(); 152| | } 153| | } 154| | else if constexpr (N == 6) { 155| | switch (index) { 156| | case 0: 157| | lambda.template operator()<0>(); 158| | break; 159| | case 1: 160| | lambda.template operator()<1>(); 161| | break; 162| | case 2: 163| | lambda.template operator()<2>(); 164| | break; 165| | case 3: 166| | lambda.template operator()<3>(); 167| | break; 168| | case 4: 169| | lambda.template operator()<4>(); 170| | break; 171| | case 5: 172| | lambda.template operator()<5>(); 173| | break; 174| | default: 175| | std::unreachable(); 176| | } 177| | } 178| | else if constexpr (N == 7) { 179| | switch (index) { 180| | case 0: 181| | lambda.template operator()<0>(); 182| | break; 183| | case 1: 184| | lambda.template operator()<1>(); 185| | break; 186| | case 2: 187| | lambda.template operator()<2>(); 188| | break; 189| | case 3: 190| | lambda.template operator()<3>(); 191| | break; 192| | case 4: 193| | lambda.template operator()<4>(); 194| | break; 195| | case 5: 196| | lambda.template operator()<5>(); 197| | break; 198| | case 6: 199| | lambda.template operator()<6>(); 200| | break; 201| | default: 202| | std::unreachable(); 203| | } 204| | } 205| | else if constexpr (N == 8) { 206| | switch (index) { 207| | case 0: 208| | lambda.template operator()<0>(); 209| | break; 210| | case 1: 211| | lambda.template operator()<1>(); 212| | break; 213| | case 2: 214| | lambda.template operator()<2>(); 215| | break; 216| | case 3: 217| | lambda.template operator()<3>(); 218| | break; 219| | case 4: 220| | lambda.template operator()<4>(); 221| | break; 222| | case 5: 223| | lambda.template operator()<5>(); 224| | break; 225| | case 6: 226| | lambda.template operator()<6>(); 227| | break; 228| | case 7: 229| | lambda.template operator()<7>(); 230| | break; 231| | default: 232| | std::unreachable(); 233| | } 234| | } 235| | else if constexpr (N == 9) { 236| | switch (index) { 237| | case 0: 238| | lambda.template operator()<0>(); 239| | break; 240| | case 1: 241| | lambda.template operator()<1>(); 242| | break; 243| | case 2: 244| | lambda.template operator()<2>(); 245| | break; 246| | case 3: 247| | lambda.template operator()<3>(); 248| | break; 249| | case 4: 250| | lambda.template operator()<4>(); 251| | break; 252| | case 5: 253| | lambda.template operator()<5>(); 254| | break; 255| | case 6: 256| | lambda.template operator()<6>(); 257| | break; 258| | case 7: 259| | lambda.template operator()<7>(); 260| | break; 261| | case 8: 262| | lambda.template operator()<8>(); 263| | break; 264| | default: 265| | std::unreachable(); 266| | } 267| | } 268| | else if constexpr (N == 10) { 269| | switch (index) { 270| | case 0: 271| | lambda.template operator()<0>(); 272| | break; 273| | case 1: 274| | lambda.template operator()<1>(); 275| | break; 276| | case 2: 277| | lambda.template operator()<2>(); 278| | break; 279| | case 3: 280| | lambda.template operator()<3>(); 281| | break; 282| | case 4: 283| | lambda.template operator()<4>(); 284| | break; 285| | case 5: 286| | lambda.template operator()<5>(); 287| | break; 288| | case 6: 289| | lambda.template operator()<6>(); 290| | break; 291| | case 7: 292| | lambda.template operator()<7>(); 293| | break; 294| | case 8: 295| | lambda.template operator()<8>(); 296| | break; 297| | case 9: 298| | lambda.template operator()<9>(); 299| | break; 300| | default: 301| | std::unreachable(); 302| | } 303| | } 304| 63.8k| else { 305| |#ifdef _MSC_VER 306| | using Lambda = std::decay_t; 307| | static const auto jump_table = [](std::index_sequence) { 308| | return std::array{make_jump_function()...}; 309| | }(std::make_index_sequence{}); 310| |#else 311| 63.8k| static constexpr auto jump_table = [](std::index_sequence) { 312| 63.8k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; 313| 63.8k| }(std::make_index_sequence{}); 314| 63.8k|#endif 315| | 316| 63.8k|#if defined(__clang_major__) && (__clang_major__ >= 19) 317| 63.8k| [[assume(index < N)]]; 318| 63.8k|#endif 319| 63.8k| jump_table[index](lambda); 320| | 321| | // This code runs significantly slower on Clang 322| | // Simple tests with assembly show that this should be faster, 323| | // but full Glaze assembly need to be looked into 324| | /*[&, index](std::index_sequence) { 325| | (void)((index == I ? lambda.template operator()() : void()), ...); 326| | }(std::make_index_sequence{});*/ 327| 63.8k| } 328| 63.8k| } 329| 63.8k| } _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E_clESU_: 312| 38.4k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E0_clESU_: 312| 144| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E1_clESU_: 312| 984| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E2_clESU_: 312| 822| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E3_clESU_: 312| 9.39k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E4_clESU_: 312| 1.49k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E5_clESU_: 312| 2.43k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E6_clESU_: 312| 9.14k| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZN3glz8for_eachILm2EZNS_28process_variant_alternativesINSt3__17variantIJNS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEN9repe_fuzz6amountEEEENS_14is_variant_strEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERSC_TkNS_10is_contextERNS_7contextERPKcSL_EEvOT0_OT1_OT2_T3_EUlTnmvE_EEvSO_: 24| 4.47k| { 25| 4.47k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 4.47k| else if constexpr (N == 2) { 32| 4.47k| lambda.template operator()<0>(); 33| 4.47k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 4.47k| } 52| 4.47k| } _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E7_clESU_: 312| 323| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E8_clESU_: 312| 126| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E9_clESU_: 312| 350| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E10_clESU_: 312| 102| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZZZN3glz5visitILm13EZNS_16parse_and_invokeITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEEN9repe_fuzz8fuzz_apiERS4_JETkNS_10is_contextERNS_7contextERPKcSA_Qoo14glaze_object_tIT0_E11reflectableISB_EEEvOT1_OT3_OT4_OT5_DpOT2_EUlTnmvE_EEvOSB_mENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSR_ENKUlRSN_E11_clESU_: 312| 106| return std::array{+[](std::decay_t& l) { l.template operator()(); }...}; _ZN3glz8for_eachILm13EZNS_2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 47| { 25| 47| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 47| else { 47| 47| [&](std::index_sequence) { 48| 47| (void)(lambda.template operator()(), ...); 49| 47| }(std::make_index_sequence{}); 50| 47| } 51| 47| } 52| 47| } _ZZN3glz8for_eachILm13EZNS_2toILj10EN9repe_fuzz8fuzz_apiEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_ENKUlTpTnmNS8_16integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSU_: 47| 47| [&](std::index_sequence) { 48| 47| (void)(lambda.template operator()(), ...); 49| 47| }(std::make_index_sequence{}); _ZN3glz8for_eachILm2EZNS_2toILj10EN9repe_fuzz5pointEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 160| { 25| 160| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 160| else if constexpr (N == 2) { 32| 160| lambda.template operator()<0>(); 33| 160| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 160| } 52| 160| } _ZN3glz8for_eachILm2EZNS_2toILj10EN9repe_fuzz6nestedEE2opITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEERS3_RNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEETkNS_10is_contextERNS_7contextEmQntsr3stdE12is_pointer_vIu14__remove_cvrefITL0_0_EEEEvOT0_OT2_OT1_RT3_EUlTnmvE_EEvSL_: 24| 91| { 25| 91| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 91| else if constexpr (N == 2) { 32| 91| lambda.template operator()<0>(); 33| 91| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 91| } 52| 91| } repe_registry.cpp:_ZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_: 24| 318k| { 25| 318k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| | else if constexpr (N == 2) { 32| | lambda.template operator()<0>(); 33| | lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| 318k| else { 47| 318k| [&](std::index_sequence) { 48| 318k| (void)(lambda.template operator()(), ...); 49| 318k| }(std::make_index_sequence{}); 50| 318k| } 51| 318k| } 52| 318k| } repe_registry.cpp:_ZZN3glz8for_eachILm13EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS8_EEEvRT0_EUlTnDavE_EEvOS9_ENKUlTpTnmNSt3__116integer_sequenceImJXspT_EEEEE_clIJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9ELm10ELm11ELm12EEEEDaSF_: 47| 318k| [&](std::index_sequence) { 48| 318k| (void)(lambda.template operator()(), ...); 49| 318k| }(std::make_index_sequence{}); repe_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz5pointEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm2EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_: 24| 318k| { 25| 318k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 318k| else if constexpr (N == 2) { 32| 318k| lambda.template operator()<0>(); 33| 318k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 318k| } 52| 318k| } repe_registry.cpp:_ZN3glz8for_eachILm2EZNS_8registryIXtlNS_4optsELj10ELb1ELb0ELb1ELb1EEELj30000EE16register_membersIL_ZNS_6detailL10empty_pathEEN9repe_fuzz6nestedEL_ZZZNS4_IL_ZNS5_L10empty_pathEENS6_8fuzz_apiEL_ZNS5_L10empty_pathEEQoo14glaze_object_tITL0_0_E11reflectableIS9_EEEvRT0_ENKUlTnDavE_clILm3EEEDavE8full_keyEQoo14glaze_object_tIS9_E11reflectableIS9_EEEvSB_EUlTnDavE_EEvOSA_: 24| 318k| { 25| 318k| if constexpr (N > 0) { 26| | // Explicit sizes for small N to help the compiler and make debugging easier 27| | // These generate less assembly with O0, but make no difference for higher optimization 28| | if constexpr (N == 1) { 29| | lambda.template operator()<0>(); 30| | } 31| 318k| else if constexpr (N == 2) { 32| 318k| lambda.template operator()<0>(); 33| 318k| lambda.template operator()<1>(); 34| | } 35| | else if constexpr (N == 3) { 36| | lambda.template operator()<0>(); 37| | lambda.template operator()<1>(); 38| | lambda.template operator()<2>(); 39| | } 40| | else if constexpr (N == 4) { 41| | lambda.template operator()<0>(); 42| | lambda.template operator()<1>(); 43| | lambda.template operator()<2>(); 44| | lambda.template operator()<3>(); 45| | } 46| | else { 47| | [&](std::index_sequence) { 48| | (void)(lambda.template operator()(), ...); 49| | }(std::make_index_sequence{}); 50| | } 51| 318k| } 52| 318k| } _ZN3glz10from_charsILb0EdcEENS_10fast_float19from_chars_result_tIT1_EEPKS3_S6_RT0_: 236| 314k| { 237| 314k| using namespace glz::fast_float; 238| 314k| static_assert(is_supported_float_type(), "only some floating-point types are supported"); 239| 314k| static_assert(is_supported_char_type(), "only char, wchar_t, char16_t and char32_t are supported"); 240| | 241| 314k| parsed_number_string_t pns = glz::parse_number_string(first, last); 242| 314k| if (!pns.valid) [[unlikely]] { ------------------ | Branch (242:11): [True: 23.3k, False: 291k] ------------------ 243| 23.3k| return {.ptr = first, .ec = std::errc::invalid_argument}; 244| 23.3k| } 245| | 246| 291k| return from_chars_advanced(pns, value); 247| 314k| } _ZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_: 18| 314k| { 19| 314k| using namespace glz::fast_float; 20| 314k| static constexpr UC decimal_point = '.'; 21| | 22| 314k| parsed_number_string_t answer; 23| 314k| answer.valid = false; 24| 314k| answer.too_many_digits = false; 25| 314k| answer.negative = (*p == UC('-')); 26| 314k| if (*p == UC('-')) { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here ------------------ | Branch (26:11): [True: 37.6k, False: 276k] ------------------ 27| 37.6k| ++p; 28| | 29| 37.6k| if constexpr (not null_terminated) { 30| 37.6k| if (p == pend) [[unlikely]] { ------------------ | Branch (30:17): [True: 18, False: 37.6k] ------------------ 31| 18| return answer; 32| 18| } 33| 37.6k| } 34| | 35| 37.6k| if (!glz::fast_float::is_integer(*p)) [[unlikely]] { // a sign must be followed by an integer ------------------ | Branch (35:14): [True: 54, False: 37.5k] ------------------ 36| 54| return answer; 37| 54| } 38| 37.6k| } 39| 314k| UC const* const start_digits = p; 40| | 41| 314k| uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad) 42| | 43| 314k| 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| 314k| else { 53| 3.55M| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (53:17): [True: 3.55M, False: 1.21k] | Branch (53:32): [True: 3.24M, False: 313k] ------------------ 54| | // a multiplication by 10 is cheaper than an arbitrary integer 55| | // multiplication 56| 3.24M| i = 10 * i + digit; // might overflow, we will handle the overflow later 57| 3.24M| ++p; 58| 3.24M| } 59| 314k| } 60| | 61| 314k| UC const* const end_of_integer_part = p; 62| 314k| int64_t digit_count = int64_t(end_of_integer_part - start_digits); 63| 314k| 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| 314k| if (digit_count == 0 || (start_digits[0] == UC('0') && digit_count > 1)) { ------------------ | Branch (66:11): [True: 23.2k, False: 291k] | Branch (66:32): [True: 11.9k, False: 279k] | Branch (66:62): [True: 43, False: 11.8k] ------------------ 67| 23.2k| return answer; 68| 23.2k| } 69| | 70| 291k| int64_t exponent = 0; 71| 291k| const bool has_decimal_point = [&] { 72| 291k| if constexpr (null_terminated) { 73| 291k| return (*p == decimal_point); 74| 291k| } 75| 291k| else { 76| 291k| return (p != pend) && (*p == decimal_point); 77| 291k| } 78| 291k| }(); 79| 291k| if (has_decimal_point) { ------------------ | Branch (79:11): [True: 25.6k, False: 265k] ------------------ 80| 25.6k| ++p; 81| 25.6k| 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| 25.6k| 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| 25.6k| else { 93| 111k| while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9) { ------------------ | Branch (93:20): [True: 110k, False: 976] | Branch (93:35): [True: 85.6k, False: 24.6k] ------------------ 94| 85.6k| ++p; 95| 85.6k| i = i * 10 + digit; // in rare cases, this will overflow, but that's ok 96| 85.6k| } 97| 25.6k| } 98| 25.6k| exponent = before - p; 99| 25.6k| answer.fraction = glz::fast_float::span(before, size_t(p - before)); 100| 25.6k| digit_count -= exponent; 101| 25.6k| } 102| | // at least 1 digit in fractional part 103| 291k| if (has_decimal_point && exponent == 0) { ------------------ | Branch (103:11): [True: 25.6k, False: 265k] | Branch (103:32): [True: 41, False: 25.6k] ------------------ 104| 41| return answer; 105| 41| } 106| | 107| 291k| int64_t exp_number = 0; // explicit exponential part 108| | 109| | if constexpr (null_terminated) { 110| | if ((UC('e') == *p) || (UC('E') == *p)) { 111| | UC const* location_of_e = p; 112| | ++p; 113| | bool neg_exp = false; 114| | if (UC('-') == *p) { 115| | neg_exp = true; 116| | ++p; 117| | } 118| | else if (UC('+') == *p) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) 119| | ++p; 120| | } 121| | if ((digit = glz::fast_float::digit_value(*p)) > 9) { 122| | // Otherwise, we will be ignoring the 'e'. 123| | p = location_of_e; 124| | } 125| | else { 126| | do { 127| | if (exp_number < 0x10000000) { 128| | exp_number = 10 * exp_number + digit; 129| | } 130| | ++p; 131| | } while ((digit = glz::fast_float::digit_value(*p)) <= 9); 132| | if (neg_exp) { 133| | exp_number = -exp_number; 134| | } 135| | exponent += exp_number; 136| | } 137| | } 138| | } 139| 291k| else { 140| 291k| if ((p != pend) && ((UC('e') == *p) || (UC('E') == *p))) { ------------------ | Branch (140:14): [True: 289k, False: 2.16k] | Branch (140:30): [True: 4.56k, False: 284k] | Branch (140:49): [True: 15.9k, False: 268k] ------------------ 141| 20.4k| UC const* location_of_e = p; 142| 20.4k| ++p; 143| 20.4k| bool neg_exp = false; 144| 20.4k| if ((p != pend) && (UC('-') == *p)) { ------------------ | Branch (144:17): [True: 20.4k, False: 83] | Branch (144:32): [True: 745, False: 19.6k] ------------------ 145| 745| neg_exp = true; 146| 745| ++p; 147| 745| } 148| 19.7k| else if ((p != pend) && (UC('+') == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1) ------------------ | Branch (148:22): [True: 19.6k, False: 83] | Branch (148:37): [True: 568, False: 19.0k] ------------------ 149| 568| ++p; 150| 568| } 151| 20.4k| if ((p == pend) || (digit = glz::fast_float::digit_value(*p)) > 9) { ------------------ | Branch (151:17): [True: 93, False: 20.3k] | Branch (151:32): [True: 91, False: 20.3k] ------------------ 152| | // Otherwise, we will be ignoring the 'e'. 153| 184| p = location_of_e; 154| 184| } 155| 20.3k| else { 156| 36.8k| do { 157| 36.8k| if (exp_number < 0x10000000) { ------------------ | Branch (157:23): [True: 35.5k, False: 1.31k] ------------------ 158| 35.5k| exp_number = 10 * exp_number + digit; 159| 35.5k| } 160| 36.8k| ++p; 161| 36.8k| } while ((p != pend) && (digit = glz::fast_float::digit_value(*p)) <= 9); ------------------ | Branch (161:25): [True: 36.0k, False: 877] | Branch (161:40): [True: 16.5k, False: 19.4k] ------------------ 162| 20.3k| if (neg_exp) { ------------------ | Branch (162:20): [True: 741, False: 19.5k] ------------------ 163| 741| exp_number = -exp_number; 164| 741| } 165| 20.3k| exponent += exp_number; 166| 20.3k| } 167| 20.4k| } 168| 291k| } 169| | 170| 291k| answer.lastmatch = p; 171| 291k| answer.valid = true; 172| | 173| | // If we frequently had to deal with long strings of digits, 174| | // we could extend our code by using a 128-bit integer instead 175| | // of a 64-bit integer. However, this is uncommon. 176| | // 177| | // We can deal with up to 19 digits. 178| 291k| if (digit_count > 19) { // this is uncommon ------------------ | Branch (178:11): [True: 32.0k, False: 259k] ------------------ 179| | // It is possible that the integer had an overflow. 180| | // We have to handle the case where we have 0.0000somenumber. 181| | // We need to be mindful of the case where we only have zeroes... 182| | // E.g., 0.000000000...000. 183| 32.0k| UC const* start = start_digits; 184| | if constexpr (null_terminated) { 185| | while ((*start == UC('0') || *start == decimal_point)) { 186| | if (*start == UC('0')) { 187| | --digit_count; 188| | } 189| | ++start; 190| | } 191| | } 192| 32.0k| else { 193| 542k| while ((start != pend) && (*start == UC('0') || *start == decimal_point)) { ------------------ | Branch (193:20): [True: 542k, False: 19] | Branch (193:40): [True: 505k, False: 36.8k] | Branch (193:61): [True: 4.82k, False: 31.9k] ------------------ 194| 510k| if (*start == UC('0')) { ------------------ | Branch (194:20): [True: 505k, False: 4.82k] ------------------ 195| 505k| --digit_count; 196| 505k| } 197| 510k| ++start; 198| 510k| } 199| 32.0k| } 200| | 201| 32.0k| if (digit_count > 19) { ------------------ | Branch (201:14): [True: 30.1k, False: 1.87k] ------------------ 202| 30.1k| answer.too_many_digits = true; 203| | // Let us start again, this time, avoiding overflows. 204| | // We don't need to check if is_integer, since we use the 205| | // pre-tokenized spans from above. 206| 30.1k| i = 0; 207| 30.1k| p = answer.integer.ptr; 208| 30.1k| UC const* int_end = p + answer.integer.len(); 209| 30.1k| const uint64_t minimal_nineteen_digit_integer{1000000000000000000}; 210| 452k| while ((i < minimal_nineteen_digit_integer) && (p != int_end)) { ------------------ | Branch (210:20): [True: 434k, False: 17.3k] | Branch (210:60): [True: 422k, False: 12.8k] ------------------ 211| 422k| i = i * 10 + uint64_t(*p - UC('0')); 212| 422k| ++p; 213| 422k| } 214| 30.1k| if (i >= minimal_nineteen_digit_integer) { // We have a big integers ------------------ | Branch (214:17): [True: 17.3k, False: 12.8k] ------------------ 215| 17.3k| exponent = end_of_integer_part - p + exp_number; 216| 17.3k| } 217| 12.8k| else { // We have a value with a fractional component. 218| 12.8k| p = answer.fraction.ptr; 219| 12.8k| UC const* frac_end = p + answer.fraction.len(); 220| 229k| while ((i < minimal_nineteen_digit_integer) && (p != frac_end)) { ------------------ | Branch (220:23): [True: 216k, False: 12.8k] | Branch (220:63): [True: 216k, False: 0] ------------------ 221| 216k| i = i * 10 + uint64_t(*p - UC('0')); 222| 216k| ++p; 223| 216k| } 224| 12.8k| exponent = answer.fraction.ptr - p + exp_number; 225| 12.8k| } 226| | // We have now corrected both exponent and i, to a truncated value 227| 30.1k| } 228| 32.0k| } 229| 291k| answer.exponent = exponent; 230| 291k| answer.mantissa = i; 231| 291k| return answer; 232| 291k| } _ZZN3glz19parse_number_stringILb0EcEENS_10fast_float22parsed_number_string_tIT0_EEPKS3_S6_ENKUlvE_clEv: 71| 291k| const bool has_decimal_point = [&] { 72| | if constexpr (null_terminated) { 73| | return (*p == decimal_point); 74| | } 75| 291k| else { 76| 291k| return (p != pend) && (*p == decimal_point); ------------------ | Branch (76:20): [True: 290k, False: 1.18k] | Branch (76:35): [True: 25.6k, False: 264k] ------------------ 77| 291k| } 78| 291k| }(); _ZN3glz8to_charsImQsr3stdE7same_asIu14__remove_cvrefIT_EmEEEPcS3_S1_: 221| 298k| { 222| 298k| using namespace itoa_impl; 223| 298k| if (val < 100000000) { ------------------ | Branch (223:11): [True: 297k, False: 1.18k] ------------------ 224| 297k| return u64_len_1_8(buf, uint32_t(val)); 225| 297k| } 226| 1.18k| else if (val < 10000000000000000ull) { ------------------ | Branch (226:16): [True: 418, False: 764] ------------------ 227| 418| const uint64_t hgh = div_1e8(val); 228| 418| const uint32_t low = uint32_t(val - hgh * 100000000); 229| 418| buf = u64_len_1_8(buf, uint32_t(hgh)); 230| 418| return u64_len_8(buf, low); 231| 418| } 232| 764| else { 233| 764| const uint64_t tmp = div_1e8(val); 234| 764| const uint32_t low = uint32_t(val - tmp * 100000000); 235| 764| const uint32_t hgh = uint32_t(tmp / 10000); 236| 764| const uint32_t mid = uint32_t(tmp - uint64_t(hgh) * 10000); 237| 764| buf = u64_len_5_8(buf, hgh); 238| 764| buf = u64_len_4(buf, mid); 239| 764| return u64_len_8(buf, low); 240| 764| } 241| 298k| } _ZN3glz9itoa_impl11u64_len_1_8EPcj: 157| 297k| { 158| 297k| if (val < 100) { ------------------ | Branch (158:14): [True: 294k, False: 3.77k] ------------------ 159| 294k| return u32_2(buf, val); 160| 294k| } 161| 3.77k| else if (val < 10000) { ------------------ | Branch (161:19): [True: 2.77k, False: 997] ------------------ 162| 2.77k| return u32_4(buf, val); 163| 2.77k| } 164| 997| else if (val < 1000000) { ------------------ | Branch (164:19): [True: 593, False: 404] ------------------ 165| 593| return u32_6(buf, val); 166| 593| } 167| 404| else { 168| 404| return u32_8(buf, val); 169| 404| } 170| 297k| } _ZN3glz9itoa_impl5u32_2EPcj: 74| 294k| { 75| 294k| const uint32_t lz = val < 10; 76| 294k| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 77| 294k| return buf + 2 - lz; 78| 294k| } _ZN3glz9itoa_impl5u32_4EPcj: 81| 2.79k| { 82| 2.79k| const uint32_t aa = (val * 5243) >> 19; // val / 100 83| 2.79k| const uint32_t lz = aa < 10; 84| 2.79k| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 85| 2.79k| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 86| 2.79k| return buf + 4 - lz; 87| 2.79k| } _ZN3glz9itoa_impl5u32_6EPcj: 90| 771| { 91| 771| const uint32_t aa = uint32_t((uint64_t(val) * 429497) >> 32); // val / 10000 92| 771| const uint32_t bbcc = val - aa * 10000; 93| 771| const uint32_t bb = (bbcc * 5243) >> 19; // bbcc / 100 94| 771| const uint32_t lz = aa < 10; 95| 771| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 96| 771| std::memcpy(buf + 2 - lz, &digit_pairs[bb], 2); 97| 771| std::memcpy(buf + 4 - lz, &digit_pairs[bbcc - bb * 100], 2); 98| 771| return buf + 6 - lz; 99| 771| } _ZN3glz9itoa_impl5u32_8EPcj: 102| 990| { 103| 990| const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40); // val / 10000 104| 990| const uint32_t ccdd = val - aabb * 10000; 105| 990| const uint32_t aa = (aabb * 5243) >> 19; // aabb / 100 106| 990| const uint32_t cc = (ccdd * 5243) >> 19; // ccdd / 100 107| 990| const uint32_t lz = aa < 10; 108| 990| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 109| 990| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 110| 990| std::memcpy(buf + 4 - lz, &digit_pairs[cc], 2); 111| 990| std::memcpy(buf + 6 - lz, &digit_pairs[ccdd - cc * 100], 2); 112| 990| return buf + 8 - lz; 113| 990| } _ZN3glz9itoa_impl7div_1e8Em: 56| 1.18k| { 57| 1.18k| constexpr __uint128_t multiplier = 0xabcc77118461cefdULL; 58| 1.18k| constexpr uint64_t shift = 90; 59| 1.18k| return static_cast((static_cast<__uint128_t>(value) * multiplier) >> shift); 60| 1.18k| } _ZN3glz9itoa_impl9u64_len_8EPcj: 134| 1.18k| { 135| 1.18k| const uint32_t aabb = uint32_t((uint64_t(val) * 109951163) >> 40); 136| 1.18k| const uint32_t ccdd = val - aabb * 10000; 137| 1.18k| const uint32_t aa = (aabb * 5243) >> 19; 138| 1.18k| const uint32_t cc = (ccdd * 5243) >> 19; 139| 1.18k| std::memcpy(buf, &digit_pairs[aa], 2); 140| 1.18k| std::memcpy(buf + 2, &digit_pairs[aabb - aa * 100], 2); 141| 1.18k| std::memcpy(buf + 4, &digit_pairs[cc], 2); 142| 1.18k| std::memcpy(buf + 6, &digit_pairs[ccdd - cc * 100], 2); 143| 1.18k| return buf + 8; 144| 1.18k| } _ZN3glz9itoa_impl11u64_len_5_8EPcj: 174| 764| { 175| 764| if (val < 1000000) { ------------------ | Branch (175:14): [True: 178, False: 586] ------------------ 176| 178| return u32_6(buf, val); 177| 178| } 178| 586| else { 179| 586| return u32_8(buf, val); 180| 586| } 181| 764| } _ZN3glz9itoa_impl9u64_len_4EPcj: 148| 764| { 149| 764| const uint32_t aa = (val * 5243) >> 19; 150| 764| std::memcpy(buf, &digit_pairs[aa], 2); 151| 764| std::memcpy(buf + 2, &digit_pairs[val - aa * 100], 2); 152| 764| return buf + 4; 153| 764| } _ZN3glz8to_charsIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_: 191| 26| { 192| 26| using namespace itoa_impl; 193| 26| if (val < 100) { ------------------ | Branch (193:11): [True: 10, False: 16] ------------------ 194| 10| return u32_2(buf, val); 195| 10| } 196| 16| else if (val < 10000) { ------------------ | Branch (196:16): [True: 16, False: 0] ------------------ 197| 16| return u32_4(buf, val); 198| 16| } 199| 0| else if (val < 1000000) { ------------------ | Branch (199:16): [True: 0, False: 0] ------------------ 200| 0| return u32_6(buf, val); 201| 0| } 202| 0| else if (val < 100000000) { ------------------ | Branch (202:16): [True: 0, False: 0] ------------------ 203| 0| return u32_8(buf, val); 204| 0| } 205| 0| else { 206| 0| return u32_10(buf, val); 207| 0| } 208| 26| } _ZN3glz13to_chars_40kbIiQsr3stdE7same_asIu14__remove_cvrefIT_EiEEEPcS3_S1_: 282| 891| { 283| 891| *buf = '-'; 284| 891| return to_chars_40kb(buf + (val < 0), 285| 891| static_cast((static_cast(val) ^ (val >> 31)) - (val >> 31))); 286| 891| } _ZN3glz13to_chars_40kbIjQsr3stdE7same_asIu14__remove_cvrefIT_EjEEEPcS3_S1_: 260| 891| { 261| 891| using namespace itoa_40kb_impl; 262| 891| if (val < 10000) { ------------------ | Branch (262:11): [True: 504, False: 387] ------------------ 263| 504| if (val < 100) ------------------ | Branch (263:14): [True: 392, False: 112] ------------------ 264| 392| return u32_2(buf, val); 265| 112| else 266| 112| return u32_4(buf, val); 267| 504| } 268| 387| else if (val < 100000000) { ------------------ | Branch (268:16): [True: 278, False: 109] ------------------ 269| 278| if (val < 1000000) ------------------ | Branch (269:14): [True: 135, False: 143] ------------------ 270| 135| return u32_6(buf, val); 271| 143| else 272| 143| return u32_8(buf, val); 273| 278| } 274| 109| else { 275| 109| return u32_10(buf, val); 276| 109| } 277| 891| } _ZN3glz14itoa_40kb_impl5u32_2EPcj: 62| 392| { 63| 392| const uint64_t lz = val < 10; 64| | // Use OR since val*2 is always even (bit 0 is 0) 65| 392| std::memcpy(buf, char_table + ((val * 2) | lz), 2); 66| 392| return buf + 2 - lz; 67| 392| } _ZN3glz14itoa_40kb_impl5u32_4EPcj: 70| 112| { 71| 112| const uint32_t aa = (val * 5243) >> 19; 72| 112| const uint64_t lz = val < 1000; 73| 112| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 74| 112| std::memcpy(buf + 2 - lz, &digit_pairs[val - aa * 100], 2); 75| 112| return buf + 4 - lz; 76| 112| } _ZN3glz14itoa_40kb_impl5u32_6EPcj: 79| 135| { 80| 135| const uint32_t aa = static_cast((static_cast(val) * 429497ULL) >> 32); 81| 135| const uint64_t lz = val < 100000; 82| 135| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 83| 135| std::memcpy(buf + 2 - lz, &digit_quads[val - aa * 10000], 4); 84| 135| return buf + 6 - lz; 85| 135| } _ZN3glz14itoa_40kb_impl5u32_8EPcj: 88| 143| { 89| 143| const uint64_t aabb = (static_cast(val) * 109951163ULL) >> 40; 90| 143| const uint64_t aa = (aabb * 5243ULL) >> 19; 91| 143| const uint64_t lz = val < 10000000; 92| 143| std::memcpy(buf, char_table + ((aa * 2) | lz), 2); 93| 143| std::memcpy(buf + 2 - lz, &digit_pairs[aabb - aa * 100], 2); 94| 143| std::memcpy(buf + 4 - lz, &digit_quads[val - aabb * 10000], 4); 95| 143| return buf + 8 - lz; 96| 143| } _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| } _ZN3glz14itoa_40kb_impl7div_1e8Em: 50| 109| { 51| 109| constexpr __uint128_t multiplier = 0xabcc77118461cefdULL; 52| 109| constexpr uint64_t shift = 90; 53| 109| return static_cast((static_cast<__uint128_t>(value) * multiplier) >> shift); 54| 109| } _ZN3glz7skip_wsIXtlNS_7ws_optsEEETkNS_10is_contextERNS_7contextERPKcS5_EEbOT0_OT1_T2_: 622| 2.53M| { 623| 2.53M| using namespace glz::detail; 624| | 625| 2.53M| if constexpr (not Opts.minified) { 626| | if constexpr (Opts.null_terminated) { 627| | if constexpr (Opts.comments) { 628| | while (whitespace_comment_table[uint8_t(*it)]) { 629| | if (*it == '/') [[unlikely]] { 630| | skip_comment(ctx, it, end); 631| | if (bool(ctx.error)) [[unlikely]] { 632| | return true; 633| | } 634| | } 635| | else [[likely]] { 636| | ++it; 637| | } 638| | } 639| | } 640| | else { 641| | while (whitespace_table[uint8_t(*it)]) { 642| | ++it; 643| | } 644| | } 645| | } 646| 2.53M| else { 647| | if constexpr (Opts.comments) { 648| | while (it < end && whitespace_comment_table[uint8_t(*it)]) { 649| | if (*it == '/') [[unlikely]] { 650| | skip_comment(ctx, it, end); 651| | if (bool(ctx.error)) [[unlikely]] { 652| | return true; 653| | } 654| | } 655| | else [[likely]] { 656| | ++it; 657| | } 658| | } 659| | if (it == end) [[unlikely]] { 660| | ctx.error = error_code::end_reached; 661| | return true; 662| | } 663| | } 664| 2.53M| else { 665| 82.6M| while (it < end && whitespace_table[uint8_t(*it)]) { ------------------ | Branch (665:23): [True: 82.6M, False: 3.44k] | Branch (665:35): [True: 80.1M, False: 2.52M] ------------------ 666| 80.1M| ++it; 667| 80.1M| } 668| 2.53M| if (it == end) [[unlikely]] { ------------------ | Branch (668:20): [True: 3.44k, False: 2.52M] ------------------ 669| 3.44k| ctx.error = error_code::end_reached; 670| 3.44k| return true; 671| 3.44k| } 672| 2.53M| } 673| 2.53M| } 674| | } 675| | else if constexpr (not Opts.null_terminated) { 676| | // Minified input has no whitespace to skip, but a non-null-terminated buffer can still 677| | // be exhausted at this point. The non-minified branch above performs the same check; a 678| | // null-terminated buffer relies on the trailing sentinel and keeps this a pure no-op. 679| | if (it == end) [[unlikely]] { 680| | ctx.error = error_code::end_reached; 681| | return true; 682| | } 683| | } 684| | 685| 2.52M| return false; 686| 2.53M| } _ZN3glz17match_invalid_endILc123EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 103k| { 412| 103k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 38.5k, False: 64.9k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| 38.5k| else if constexpr (C == '{' || C == '}') { 426| 38.5k| ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 38.5k| return true; 432| 38.5k| } 433| 64.9k| else [[likely]] { 434| 64.9k| ++it; 435| 64.9k| } 436| 64.9k| if constexpr (not Opts.null_terminated) { 437| 64.9k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 73, False: 64.9k] ------------------ 438| 73| ctx.error = error_code::unexpected_end; 439| 73| return true; 440| 73| } 441| 64.9k| } 442| 64.9k| return false; 443| 103k| } _ZN3glz17match_invalid_endILc44EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 197k| { 412| 197k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 2.32k, False: 194k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| 2.32k| else if constexpr (C == ',') { 417| 2.32k| ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 2.32k| return true; 432| 2.32k| } 433| 194k| else [[likely]] { 434| 194k| ++it; 435| 194k| } 436| 194k| if constexpr (not Opts.null_terminated) { 437| 194k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 145, False: 194k] ------------------ 438| 145| ctx.error = error_code::unexpected_end; 439| 145| return true; 440| 145| } 441| 194k| } 442| 194k| return false; 443| 197k| } _ZN3glz16skip_matching_wsIcRPKcEEvPKT_OT0_m: 689| 518k| { 690| 518k| if (length > 7) { ------------------ | Branch (690:11): [True: 47.3k, False: 471k] ------------------ 691| 47.3k| uint64_t v[2]; 692| 59.1k| while (length > 8) { ------------------ | Branch (692:17): [True: 41.1k, False: 18.0k] ------------------ 693| 41.1k| std::memcpy(v, ws, 8); 694| 41.1k| std::memcpy(v + 1, it, 8); 695| 41.1k| if (v[0] != v[1]) { ------------------ | Branch (695:17): [True: 29.3k, False: 11.7k] ------------------ 696| 29.3k| return; 697| 29.3k| } 698| 11.7k| length -= 8; 699| 11.7k| ws += 8; 700| 11.7k| it += 8; 701| 11.7k| } 702| | 703| 18.0k| const auto shift = 8 - length; 704| 18.0k| ws -= shift; 705| 18.0k| it -= shift; 706| | 707| 18.0k| std::memcpy(v, ws, 8); 708| 18.0k| std::memcpy(v + 1, it, 8); 709| 18.0k| if (v[0] != v[1]) { ------------------ | Branch (709:14): [True: 13.1k, False: 4.87k] ------------------ 710| 13.1k| return; 711| 13.1k| } 712| 4.87k| it += 8; 713| 4.87k| return; 714| 18.0k| } 715| 471k| { 716| 471k| constexpr uint64_t n{sizeof(uint32_t)}; 717| 471k| if (length >= n) { ------------------ | Branch (717:14): [True: 26.0k, False: 445k] ------------------ 718| 26.0k| uint32_t v[2]; 719| 26.0k| std::memcpy(v, ws, n); 720| 26.0k| std::memcpy(v + 1, it, n); 721| 26.0k| if (v[0] != v[1]) { ------------------ | Branch (721:17): [True: 21.9k, False: 4.10k] ------------------ 722| 21.9k| return; 723| 21.9k| } 724| 4.10k| length -= n; 725| 4.10k| ws += n; 726| 4.10k| it += n; 727| 4.10k| } 728| 471k| } 729| 449k| { 730| 449k| constexpr uint64_t n{sizeof(uint16_t)}; 731| 449k| if (length >= n) { ------------------ | Branch (731:14): [True: 96.3k, False: 353k] ------------------ 732| 96.3k| uint16_t v[2]; 733| 96.3k| std::memcpy(v, ws, n); 734| 96.3k| std::memcpy(v + 1, it, n); 735| 96.3k| if (v[0] != v[1]) { ------------------ | Branch (735:17): [True: 84.1k, False: 12.1k] ------------------ 736| 84.1k| return; 737| 84.1k| } 738| | // length -= n; 739| | // ws += n; 740| 12.1k| it += n; 741| 12.1k| } 742| 449k| } 743| | // We have to call a whitespace check after this function 744| | // in case the whitespace is mismatching. 745| | // So, we forgo this check as to not duplicate. 746| | /*if (length && *ws == *it) { 747| | ++it; 748| | }*/ 749| 449k| } _ZN3glz17match_invalid_endILc58EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 213k| { 412| 213k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 687, False: 213k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| 687| else if constexpr (C == ':') { 420| 687| ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 687| return true; 432| 687| } 433| 213k| else [[likely]] { 434| 213k| ++it; 435| 213k| } 436| 213k| if constexpr (not Opts.null_terminated) { 437| 213k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 152, False: 213k] ------------------ 438| 152| ctx.error = error_code::unexpected_end; 439| 152| return true; 440| 152| } 441| 213k| } 442| 213k| return false; 443| 213k| } _ZN3glz9has_quoteEm: 534| 12.1M| { 535| 12.1M| return has_zero(chunk ^ repeat_byte8('"')); 536| 12.1M| } _ZN3glz8has_zeroEm: 529| 12.1M| { 530| 12.1M| return (((chunk - 0x0101010101010101u) & ~chunk) & 0x8080808080808080u); 531| 12.1M| } _ZN3glz16skip_string_viewITkNS_10is_contextERNS_7contextERPKcS4_EEvOT_OT0_T1_: 863| 507| { 864| 1.55k| while (it < end) [[likely]] { ------------------ | Branch (864:14): [True: 1.49k, False: 55] ------------------ 865| 1.49k| const auto* pc = std::memchr(it, '"', size_t(end - it)); 866| 1.49k| if (pc) [[likely]] { ------------------ | Branch (866:14): [True: 1.46k, False: 32] ------------------ 867| 1.46k| it = reinterpret_cast>(pc); 868| 1.46k| auto* prev = it - 1; 869| 2.96k| while (*prev == '\\') { ------------------ | Branch (869:20): [True: 1.49k, False: 1.46k] ------------------ 870| 1.49k| --prev; 871| 1.49k| } 872| 1.46k| if (size_t(it - prev) % 2) { ------------------ | Branch (872:17): [True: 420, False: 1.04k] ------------------ 873| 420| return; 874| 420| } 875| 1.04k| ++it; // skip the escaped quote 876| 1.04k| } 877| 32| else [[unlikely]] { 878| 32| break; 879| 32| } 880| 1.49k| } 881| | 882| 87| ctx.error = error_code::expected_quote; 883| 87| } _ZN3glz13validate_utf8IcEEbPKT_m: 801| 4.35k| { 802| 4.35k| const uint8_t* it = reinterpret_cast(str); 803| 4.35k| const uint8_t* const end = it + size; 804| |#if defined(GLZ_UTF8_SIMD) 805| | // 16 is a measured compromise, not a register-size coincidence. The scalar path skips ASCII 8 806| | // bytes at a time, so on ASCII it stays ahead of the vector path's fixed setup cost until the 807| | // input is long enough for the 64 byte ASCII step to engage; on non-ASCII the vector path 808| | // wins from roughly 8 bytes. Raising the threshold buys a few percent on short ASCII and 809| | // costs up to 2.3x on mid length non-ASCII strings, so it stays low. 810| | if (size >= 16) { 811| | return detail::utf8_simd::validate(it, end); 812| | } 813| |#endif 814| 4.35k| return validate_utf8_scalar(it, end); 815| 4.35k| } _ZN3glz20validate_utf8_scalarEPKhS1_: 752| 4.35k| { 753| 1.49M| while (it < end) { ------------------ | Branch (753:14): [True: 1.49M, False: 3.13k] ------------------ 754| | // Optimistic SWAR check for ASCII 755| 1.49M| if (it + 8 <= end) { ------------------ | Branch (755:14): [True: 1.48M, False: 9.38k] ------------------ 756| 1.48M| uint64_t chunk; 757| 1.48M| std::memcpy(&chunk, it, 8); 758| 1.48M| if ((chunk & glz::repeat_byte8(0x80)) == 0) { ------------------ | Branch (758:17): [True: 1.46M, False: 14.0k] ------------------ 759| 1.46M| it += 8; 760| 1.46M| continue; 761| 1.46M| } 762| 1.48M| } 763| | 764| | // Byte-by-byte validation (standard conformant) 765| 23.3k| uint8_t byte = *it; 766| | 767| 23.3k| if (byte < 0x80) { ------------------ | Branch (767:14): [True: 15.1k, False: 8.25k] ------------------ 768| 15.1k| it++; 769| 15.1k| } 770| 8.25k| else if ((byte & 0xE0) == 0xC0) { ------------------ | Branch (770:19): [True: 1.30k, False: 6.95k] ------------------ 771| | // 2-byte sequence 772| 1.30k| if (it + 2 > end || (it[1] & 0xC0) != 0x80) return false; ------------------ | Branch (772:17): [True: 53, False: 1.24k] | Branch (772:33): [True: 87, False: 1.16k] ------------------ 773| 1.16k| if (byte < 0xC2) return false; // Overlong ------------------ | Branch (773:17): [True: 46, False: 1.11k] ------------------ 774| 1.11k| it += 2; 775| 1.11k| } 776| 6.95k| else if ((byte & 0xF0) == 0xE0) { ------------------ | Branch (776:19): [True: 2.13k, False: 4.81k] ------------------ 777| | // 3-byte sequence 778| 2.13k| if (it + 3 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80) return false; ------------------ | Branch (778:17): [True: 42, False: 2.09k] | Branch (778:33): [True: 77, False: 2.01k] | Branch (778:59): [True: 54, False: 1.96k] ------------------ 779| 1.96k| if (byte == 0xE0 && it[1] < 0xA0) return false; // Overlong ------------------ | Branch (779:17): [True: 1.09k, False: 872] | Branch (779:33): [True: 81, False: 1.00k] ------------------ 780| 1.88k| if (byte == 0xED && it[1] >= 0xA0) return false; // Surrogate ------------------ | Branch (780:17): [True: 669, False: 1.21k] | Branch (780:33): [True: 59, False: 610] ------------------ 781| 1.82k| it += 3; 782| 1.82k| } 783| 4.81k| else if ((byte & 0xF8) == 0xF0) { ------------------ | Branch (783:19): [True: 4.49k, False: 325] ------------------ 784| | // 4-byte sequence 785| 4.49k| if (it + 4 > end || (it[1] & 0xC0) != 0x80 || (it[2] & 0xC0) != 0x80 || (it[3] & 0xC0) != 0x80) ------------------ | Branch (785:17): [True: 46, False: 4.44k] | Branch (785:33): [True: 74, False: 4.37k] | Branch (785:59): [True: 65, False: 4.30k] | Branch (785:85): [True: 67, False: 4.23k] ------------------ 786| 252| return false; 787| 4.23k| if (byte == 0xF0 && it[1] < 0x90) return false; // Overlong ------------------ | Branch (787:17): [True: 926, False: 3.31k] | Branch (787:33): [True: 42, False: 884] ------------------ 788| 4.19k| if (byte == 0xF4 && it[1] >= 0x90) return false; // > U+10FFFF ------------------ | Branch (788:17): [True: 1.52k, False: 2.66k] | Branch (788:33): [True: 55, False: 1.47k] ------------------ 789| 4.14k| if (byte > 0xF4) return false; // > U+10FFFF ------------------ | Branch (789:17): [True: 50, False: 4.09k] ------------------ 790| 4.09k| it += 4; 791| 4.09k| } 792| 325| else { 793| 325| return false; 794| 325| } 795| 23.3k| } 796| | 797| 3.13k| return true; 798| 4.35k| } _ZN3glz17match_invalid_endILc34EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 133k| { 412| 133k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 36.6k, False: 96.5k] ------------------ 413| 36.6k| if constexpr (C == '"') { 414| 36.6k| ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| | else if constexpr (C == '[' || C == ']') { 423| | ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 36.6k| return true; 432| 36.6k| } 433| 96.5k| else [[likely]] { 434| 96.5k| ++it; 435| 96.5k| } 436| 96.5k| if constexpr (not Opts.null_terminated) { 437| 96.5k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 101, False: 96.4k] ------------------ 438| 101| ctx.error = error_code::unexpected_end; 439| 101| return true; 440| 101| } 441| 96.5k| } 442| 96.4k| return false; 443| 133k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1ELb0ELb0ELb0ELb0ELj4EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 12.0k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 12.0k| else { 840| 12.0k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 10.4k, False: 1.62k] ------------------ 841| 10.4k| return false; // pure ASCII is trivially well formed UTF-8 842| 10.4k| } 843| 1.62k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 407, False: 1.21k] ------------------ 844| 407| ctx.error = error_code::invalid_utf8; 845| 407| return true; 846| 407| } 847| 1.21k| return false; 848| 1.62k| } 849| 12.0k| } _ZN3glz25handle_unicode_code_pointIccEEjRPKT_RPT0_S3_: 288| 41.7k| { 289| 41.7k| using namespace unicode; 290| | 291| 41.7k| if (it + 4 >= end) [[unlikely]] { ------------------ | Branch (291:11): [True: 48, False: 41.6k] ------------------ 292| 48| return false; 293| 48| } 294| 41.6k| const uint32_t high = hex_to_u32(it); 295| 41.6k| if (high == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (295:11): [True: 135, False: 41.5k] ------------------ 296| 135| return false; 297| 135| } 298| 41.5k| it += 4; // skip the code point characters 299| | 300| 41.5k| uint32_t code_point; 301| | 302| 41.5k| if ((high & generic_surrogate_mask) == generic_surrogate_value) { ------------------ | Branch (302:11): [True: 2.45k, False: 39.0k] ------------------ 303| | // surrogate pair code points 304| 2.45k| if ((high & surrogate_mask) != high_surrogate_value) { ------------------ | Branch (304:14): [True: 63, False: 2.38k] ------------------ 305| 63| return false; 306| 63| } 307| | 308| 2.38k| if (it + 6 >= end) [[unlikely]] { ------------------ | Branch (308:14): [True: 38, False: 2.35k] ------------------ 309| 38| return false; 310| 38| } 311| | // The next two characters must be `\u` 312| 2.35k| uint16_t u; 313| 2.35k| std::memcpy(&u, it, 2); 314| 2.35k| if (u != to_uint16_t(R"(\u)")) [[unlikely]] { ------------------ | Branch (314:14): [True: 182, False: 2.16k] ------------------ 315| 182| return false; 316| 182| } 317| 2.16k| it += 2; 318| | // verify that second unicode escape sequence is present 319| 2.16k| const uint32_t low = hex_to_u32(it); 320| 2.16k| if (low == 0xFFFFFFFFu) [[unlikely]] { ------------------ | Branch (320:14): [True: 65, False: 2.10k] ------------------ 321| 65| return false; 322| 65| } 323| 2.10k| it += 4; 324| | 325| 2.10k| if ((low & surrogate_mask) != low_surrogate_value) [[unlikely]] { ------------------ | Branch (325:14): [True: 164, False: 1.93k] ------------------ 326| 164| return false; 327| 164| } 328| | 329| 1.93k| code_point = (high & surrogate_codepoint_mask) << surrogate_codepoint_bits; 330| 1.93k| code_point |= (low & surrogate_codepoint_mask); 331| 1.93k| code_point += surrogate_codepoint_offset; 332| 1.93k| } 333| 39.0k| else { 334| 39.0k| code_point = high; 335| 39.0k| } 336| 41.0k| const uint32_t offset = code_point_to_utf8(code_point, dst); 337| 41.0k| dst += offset; 338| 41.0k| return offset; 339| 41.5k| } _ZN3glz10hex_to_u32EPKc: 203| 43.8k| { 204| 43.8k| constexpr auto& t = digit_hex_table; 205| 43.8k| const uint8_t arr[4]{t[uint8_t(c[3])], t[uint8_t(c[2])], t[uint8_t(c[1])], t[uint8_t(c[0])]}; 206| 43.8k| auto chunk = std::bit_cast(arr); 207| | // On big-endian, bit_cast produces bytes in opposite order than expected 208| | // byteswap to get consistent little-endian representation 209| | if constexpr (std::endian::native == std::endian::big) { 210| | chunk = std::byteswap(chunk); 211| | } 212| | // check that all hex characters are valid 213| 43.8k| if (chunk & repeat_byte4(0b11110000u)) [[unlikely]] { ------------------ | Branch (213:11): [True: 200, False: 43.6k] ------------------ 214| 200| return 0xFFFFFFFFu; 215| 200| } 216| | 217| | // now pack into first four bytes of uint32_t 218| 43.6k| uint32_t packed{}; 219| 43.6k| packed |= (chunk & 0x0000000F); 220| 43.6k| packed |= (chunk & 0x00000F00) >> 4; 221| 43.6k| packed |= (chunk & 0x000F0000) >> 8; 222| 43.6k| packed |= (chunk & 0x0F000000) >> 12; 223| 43.6k| return packed; 224| 43.8k| } _ZN3glz18code_point_to_utf8IcEEjjPT_: 228| 41.0k| { 229| 41.0k| if (code_point <= 0x7F) { ------------------ | Branch (229:11): [True: 14.7k, False: 26.2k] ------------------ 230| 14.7k| c[0] = Char(code_point); 231| 14.7k| return 1; 232| 14.7k| } 233| 26.2k| if (code_point <= 0x7FF) { ------------------ | Branch (233:11): [True: 3.99k, False: 22.2k] ------------------ 234| 3.99k| c[0] = Char(0xC0 | ((code_point >> 6) & 0x1F)); 235| 3.99k| c[1] = Char(0x80 | (code_point & 0x3F)); 236| 3.99k| return 2; 237| 3.99k| } 238| 22.2k| if (code_point <= 0xFFFF) { ------------------ | Branch (238:11): [True: 20.3k, False: 1.93k] ------------------ 239| 20.3k| c[0] = Char(0xE0 | ((code_point >> 12) & 0x0F)); 240| 20.3k| c[1] = Char(0x80 | ((code_point >> 6) & 0x3F)); 241| 20.3k| c[2] = Char(0x80 | (code_point & 0x3F)); 242| 20.3k| return 3; 243| 20.3k| } 244| 1.93k| if (code_point <= 0x10FFFF) { ------------------ | Branch (244:11): [True: 1.93k, False: 0] ------------------ 245| 1.93k| c[0] = Char(0xF0 | ((code_point >> 18) & 0x07)); 246| 1.93k| c[1] = Char(0x80 | ((code_point >> 12) & 0x3F)); 247| 1.93k| c[2] = Char(0x80 | ((code_point >> 6) & 0x3F)); 248| 1.93k| c[3] = Char(0x80 | (code_point & 0x3F)); 249| 1.93k| return 4; 250| 1.93k| } 251| 0| return 0; 252| 1.93k| } _ZN3glz17match_invalid_endILc91EXtlNS_22match_invalid_end_optsEEETkNS_10is_contextENS_7contextERPKcS4_EEbRT1_OT2_T3_: 411| 35.3k| { 412| 35.3k| if (*it != C) [[unlikely]] { ------------------ | Branch (412:11): [True: 22.0k, False: 13.2k] ------------------ 413| | if constexpr (C == '"') { 414| | ctx.error = error_code::expected_quote; 415| | } 416| | else if constexpr (C == ',') { 417| | ctx.error = error_code::expected_comma; 418| | } 419| | else if constexpr (C == ':') { 420| | ctx.error = error_code::expected_colon; 421| | } 422| 22.0k| else if constexpr (C == '[' || C == ']') { 423| 22.0k| ctx.error = error_code::expected_bracket; 424| | } 425| | else if constexpr (C == '{' || C == '}') { 426| | ctx.error = error_code::expected_brace; 427| | } 428| | else { 429| | ctx.error = error_code::syntax_error; 430| | } 431| 22.0k| return true; 432| 22.0k| } 433| 13.2k| else [[likely]] { 434| 13.2k| ++it; 435| 13.2k| } 436| 13.2k| if constexpr (not Opts.null_terminated) { 437| 13.2k| if (it == end) [[unlikely]] { ------------------ | Branch (437:14): [True: 20, False: 13.2k] ------------------ 438| 20| ctx.error = error_code::unexpected_end; 439| 20| return true; 440| 20| } 441| 13.2k| } 442| 13.2k| return false; 443| 35.3k| } _ZN3glz18validate_utf8_spanITnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextEccEEbOT0_PKT1_PKT2_m: 832| 82.8k| { 833| | if constexpr (not check_validate_utf8(Opts)) { 834| | // Everything the caller computed for us is dead, which lets its scan loop drop the 835| | // accumulator entirely. 836| | (void)ctx, (void)start, (void)fin, (void)ascii_acc; 837| | return false; 838| | } 839| 82.8k| else { 840| 82.8k| if ((ascii_acc & repeat_byte8(0b10000000)) == 0) { ------------------ | Branch (840:14): [True: 80.1k, False: 2.73k] ------------------ 841| 80.1k| return false; // pure ASCII is trivially well formed UTF-8 842| 80.1k| } 843| 2.73k| if (!validate_utf8(start, size_t(fin - start))) [[unlikely]] { ------------------ | Branch (843:14): [True: 816, False: 1.92k] ------------------ 844| 816| ctx.error = error_code::invalid_utf8; 845| 816| return true; 846| 816| } 847| 1.92k| return false; 848| 2.73k| } 849| 82.8k| } _ZN3glz5matchITnNS_14string_literalEXtlNS1_ILm4EEEtlA4_cLc117ELc108ELc108EEEETnDaXtlNS_4optsELj10ELb0ELb0ELb1ELb1EEETkNS_10is_contextERNS_7contextERPKcS8_Qntcl15check_is_paddedT0_EEEvOT1_OT2_T3_: 491| 1.15k| { 492| 1.15k| const auto n = size_t(end - it); 493| 1.15k| static constexpr auto S = str.sv(); 494| 1.15k| if ((n < str.size()) || not comparitor(it)) [[unlikely]] { ------------------ | Branch (494:11): [True: 9, False: 1.15k] | Branch (494:31): [True: 63, False: 1.08k] ------------------ 495| 72| ctx.error = error_code::syntax_error; 496| 72| } 497| 1.08k| else [[likely]] { 498| 1.08k| it += str.size(); 499| 1.08k| } 500| 1.15k| } _ZN3glz5matchILc34ETkNS_10is_contextENS_7contextERPKcEEbRT0_OT1_: 447| 420| { 448| 420| if (*it != C) [[unlikely]] { ------------------ | Branch (448:11): [True: 0, False: 420] ------------------ 449| 0| if constexpr (C == '"') { 450| 0| ctx.error = error_code::expected_quote; 451| | } 452| | else if constexpr (C == ',') { 453| | ctx.error = error_code::expected_comma; 454| | } 455| | else if constexpr (C == ':') { 456| | ctx.error = error_code::expected_colon; 457| | } 458| | else if constexpr (C == '[' || C == ']') { 459| | ctx.error = error_code::expected_bracket; 460| | } 461| | else if constexpr (C == '{' || C == '}') { 462| | ctx.error = error_code::expected_brace; 463| | } 464| | else { 465| | ctx.error = error_code::syntax_error; 466| | } 467| 0| return true; 468| 0| } 469| 420| else [[likely]] { 470| 420| ++it; 471| 420| return false; 472| 420| } 473| 420| } _ZNK3glz14string_literalILm4EE4sizeEv: 25| 2.24k| [[nodiscard]] constexpr size_t size() const noexcept { return length; } _ZN3glz6detail15get_source_infoITkNS_8has_sizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEENS0_11source_infoERKT_m: 39| 151k| { 40| 151k| using V = std::decay_t; 41| | 42| | if constexpr (std::same_as) { 43| | return {.context = "", .index = index}; 44| | } 45| 151k| else { 46| 151k| if (index >= buffer.size()) { ------------------ | Branch (46:17): [True: 5.06k, False: 146k] ------------------ 47| 5.06k| return {.context = "", .index = index}; 48| 5.06k| } 49| | 50| 146k| const auto start = std::begin(buffer) + index; 51| 146k| const auto line = size_t(std::count(std::begin(buffer), start, static_cast('\n')) + 1); 52| 146k| const auto rstart = std::rbegin(buffer) + buffer.size() - index - 1; 53| 146k| const auto prev_new_line = 54| 146k| std::find((std::min)(rstart + 1, std::rend(buffer)), std::rend(buffer), static_cast('\n')); 55| 146k| const auto column = size_t(std::distance(rstart, prev_new_line)); 56| 146k| const auto next_new_line = 57| 146k| std::find((std::min)(start + 1, std::end(buffer)), std::end(buffer), static_cast('\n')); 58| | 59| 146k| const auto offset = (prev_new_line == std::rend(buffer) ? 0 : index - column + 1); ------------------ | Branch (59:34): [True: 143k, False: 2.76k] ------------------ 60| 146k| auto context_begin = std::begin(buffer) + offset; 61| 146k| auto context_end = next_new_line; 62| | 63| 146k| size_t front_truncation = 0; 64| 146k| size_t rear_truncation = 0; 65| | 66| 146k| if (std::distance(context_begin, context_end) > 64) { ------------------ | Branch (66:17): [True: 32.4k, False: 113k] ------------------ 67| | // reduce the context length so that we can more easily see errors, especially for non-prettified buffers 68| 32.4k| if (column <= 32) { ------------------ | Branch (68:20): [True: 29.1k, False: 3.30k] ------------------ 69| 29.1k| rear_truncation = 64; 70| 29.1k| context_end = context_begin + rear_truncation; 71| 29.1k| } 72| 3.30k| else { 73| 3.30k| front_truncation = column - 32; 74| 3.30k| context_begin += front_truncation; 75| 3.30k| if (std::distance(context_begin, context_end) > 64) { ------------------ | Branch (75:23): [True: 1.41k, False: 1.88k] ------------------ 76| 1.41k| rear_truncation = front_truncation + 64; 77| 1.41k| context_end = std::begin(buffer) + offset + rear_truncation; 78| 1.41k| } 79| 3.30k| } 80| 32.4k| } 81| | 82| 146k| std::string context{context_begin, context_end}; 83| 146k| convert_tabs_to_single_spaces(context); 84| 146k| return {line, column, context, index, front_truncation, rear_truncation}; 85| 151k| } 86| 151k| } _ZN3glz6detail29convert_tabs_to_single_spacesERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 30| 146k| { 31| 4.27M| for (auto& c : input) { ------------------ | Branch (31:23): [True: 4.27M, False: 146k] ------------------ 32| 4.27M| if (c == '\t') { ------------------ | Branch (32:17): [True: 360k, False: 3.91M] ------------------ 33| 360k| c = ' '; 34| 360k| } 35| 4.27M| } 36| 146k| } _ZN3glz6detail21generate_error_stringENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS0_11source_infoES5_: 97| 151k| { 98| 151k| std::string b{}; 99| 151k| b.resize(error.size() + info.context.size() + filename.size() + 128); 100| 151k| size_t ix{}; 101| | 102| 151k| if (not filename.empty()) { ------------------ | Branch (102:14): [True: 0, False: 151k] ------------------ 103| 0| dump_not_empty(filename, b, ix); 104| 0| dump(':', b, ix); 105| 0| } 106| | 107| 151k| glz::context ctx{}; 108| | 109| | // Diagnostic numbers (index/line/column) are always formatted with size-optimized 110| | // integer conversion: error formatting is never a throughput path, and this keeps 111| | // glz::format_error from pulling in the 40 KB integer table regardless of the 112| | // optimization level used elsewhere in the program. 113| 151k| if (info.context.empty()) { ------------------ | Branch (113:14): [True: 5.06k, False: 146k] ------------------ 114| 5.06k| dump("index ", b, ix); 115| 5.06k| write_chars::op(info.index, ctx, b, ix); 116| 5.06k| dump(": ", b, ix); 117| 5.06k| dump_maybe_empty(error, b, ix); 118| 5.06k| } 119| 146k| else { 120| 146k| write_chars::op(info.line, ctx, b, ix); 121| 146k| dump(':', b, ix); 122| 146k| write_chars::op(info.column, ctx, b, ix); 123| 146k| dump(": ", b, ix); 124| 146k| dump_maybe_empty(error, b, ix); 125| 146k| dump('\n', b, ix); 126| 146k| if (info.front_truncation) { ------------------ | Branch (126:17): [True: 3.30k, False: 142k] ------------------ 127| 3.30k| if (info.rear_truncation) { ------------------ | Branch (127:20): [True: 1.41k, False: 1.88k] ------------------ 128| 1.41k| dump("...", b, ix); 129| 1.41k| dump_maybe_empty(info.context, b, ix); 130| 1.41k| dump("...\n ", b, ix); 131| 1.41k| } 132| 1.88k| else { 133| 1.88k| dump("...", b, ix); 134| 1.88k| dump_maybe_empty(info.context, b, ix); 135| 1.88k| dump("\n ", b, ix); 136| 1.88k| } 137| 3.30k| } 138| 142k| else { 139| 142k| dump(" ", b, ix); 140| 142k| dump_maybe_empty(info.context, b, ix); 141| 142k| dump("\n ", b, ix); 142| 142k| } 143| 146k| dumpn(' ', info.column - 1 - info.front_truncation, b, ix); 144| 146k| dump('^', b, ix); 145| 146k| } 146| | 147| 151k| b.resize(ix); 148| 151k| return b; 149| 151k| } _ZN3glz8to_charsITkNSt3__114floating_pointEdLb0EEEPcS2_T_: 1118| 988| { 1119| 988| static_assert(std::is_same_v || std::is_same_v); 1120| 988| return zmij::detail::write(val, buf); 1121| 988| } _ZN3glz4zmij6detail5writeIdLb0EEEPcT_S3_: 975| 988| { 976| 988| using namespace detail_impl; 977| 988| using traits = float_traits; 978| 988| auto bits = traits::to_bits(value); 979| 988| auto bin_exp = traits::get_exp(bits); 980| 988| auto bin_sig = traits::get_sig(bits); 981| | 982| 988| *buffer = '-'; 983| 988| buffer += traits::is_negative(bits); 984| | 985| 988| const auto* c = &consts_v; 986| 988| ZMIJ_ASM(("" : "+r"(c))); ------------------ | | 126| 988|#define ZMIJ_ASM(x) asm x ------------------ 987| 988| int64_t threshold = traits::num_bits == 64 ? static_cast(c->threshold) : 10'000'000; ------------------ | Branch (987:30): [True: 988, Folded] ------------------ 988| | 989| 988| to_decimal_result dec; 990| 988| bool is_normal = unsigned(bin_exp - 1) < unsigned(traits::exp_mask - 1); 991| 988| if (!is_normal) [[unlikely]] { ------------------ | Branch (991:14): [True: 479, False: 509] ------------------ 992| 479| if (bin_exp != 0) { ------------------ | Branch (992:17): [True: 0, False: 479] ------------------ 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| 479| if (bin_sig == 0) { ------------------ | Branch (1004:17): [True: 310, False: 169] ------------------ 1005| 310| memcpy(buffer, "0", 2); 1006| 310| return buffer + 1; 1007| 310| } 1008| 169| dec = detail_impl::to_decimal(bin_sig, 1, true, *c); 1009| 169| int64_t dec_sig = dec.sig * 10 + (dec.has_last_digit ? dec.last_digit : 0); ------------------ | Branch (1009:47): [True: 20, False: 149] ------------------ 1010| 169| int32_t dec_exp = dec.exp; 1011| 965| while (dec_sig < threshold) { ------------------ | Branch (1011:20): [True: 796, False: 169] ------------------ 1012| 796| dec_sig *= 10; 1013| 796| --dec_exp; 1014| 796| } 1015| 169| int64_t d = static_cast(detail_impl::div10(static_cast(dec_sig))); 1016| 169| int32_t last_digit = static_cast(dec_sig - d * 10); 1017| 169| dec = {d, dec_exp, last_digit, last_digit != 0}; 1018| 169| } 1019| 509| else { 1020| 509| dec = detail_impl::to_decimal(bin_sig | traits::implicit_bit, 1021| 509| bin_exp, bin_sig != 0, *c); 1022| 509| } 1023| 678| bool extra_digit = dec.sig >= threshold; 1024| 678| int dec_exp = dec.exp + traits::max_digits10 - 2 + extra_digit; 1025| 678| if (traits::num_bits == 32 && dec.sig < 1'000'000) [[unlikely]] { ------------------ | Branch (1025:14): [Folded, False: 678] | 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| 678| char* start = buffer; 1032| 678| auto dig = to_digits(static_cast(dec.sig), extra_digit, *c); 1033| 678| constexpr int bcd_size = traits::num_bits == 64 ? 16 : 8; ------------------ | Branch (1033:35): [True: 0, Folded] ------------------ 1034| 678| if (dec_exp >= traits::min_fixed_dec_exp && dec_exp <= traits::max_fixed_dec_exp) { ------------------ | Branch (1034:14): [True: 467, False: 211] | Branch (1034:54): [True: 356, False: 111] ------------------ 1035| 356| memcpy(start, &zeros_v, 8); 1036| 356| const auto& fmt = dec_exp_formats.get(dec_exp); 1037| 356| buffer += fmt.start_pos; 1038| 356| memcpy(buffer, &dig.digits, bcd_size); 1039| 356| memmove(buffer, buffer + !extra_digit, bcd_size); 1040| 356| buffer[bcd_size + extra_digit - 1] = static_cast('0' + (dec.has_last_digit ? dec.last_digit : 0)); ------------------ | Branch (1040:75): [True: 30, False: 326] ------------------ 1041| 356| memmove(start + fmt.shift_pos, start + fmt.point_pos, bcd_size); 1042| 356| start[fmt.point_pos] = '.'; 1043| 356| int num_digits = dec.has_last_digit ? bcd_size : dig.num_digits - 1; ------------------ | Branch (1043:30): [True: 30, False: 326] ------------------ 1044| 356| return buffer + fmt.exp_pos[num_digits + extra_digit - 1]; 1045| 356| } 1046| 322| buffer += extra_digit; 1047| 322| memcpy(buffer, &dig.digits, bcd_size); 1048| 322| buffer[bcd_size] = static_cast('0' + dec.last_digit); 1049| 322| buffer += dec.has_last_digit ? bcd_size + 1 : dig.num_digits; ------------------ | Branch (1049:20): [True: 40, False: 282] ------------------ 1050| 322| start[0] = start[1]; 1051| 322| start[1] = '.'; 1052| 322| buffer -= (buffer - 1 == start + 1); 1053| | 1054| 322| if constexpr (exp_string_table::enable) { 1055| 322| uint64_t exp_data = exp_strings_v.data[dec_exp + exp_string_table::offset]; 1056| 322| int len = int(exp_data >> 48); 1057| 322| if (is_big_endian) exp_data = bswap64(exp_data); ------------------ | Branch (1057:17): [Folded, False: 322] ------------------ 1058| 322| memcpy(buffer, &exp_data, traits::max_exponent10 >= 100 ? 8 : 4); ------------------ | Branch (1058:39): [True: 322, Folded] ------------------ 1059| 322| return buffer + len; 1060| 322| } 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| 322| buffer[0] = 'E'; 1067| 322| buffer[1] = '-'; 1068| 322| buffer += 1 + unsigned(neg); 1069| 322| dec_exp = neg ? -dec_exp : dec_exp; ------------------ | Branch (1069:20): [True: 0, False: 322] ------------------ 1070| 322| unsigned hundreds_written = 0; 1071| 322| if constexpr (traits::max_exponent10 >= 100) { 1072| 322| int32_t digit = 0; 1073| | if constexpr (use_umul128_hi64) { 1074| | digit = static_cast(umul128_hi64(static_cast(dec_exp), 0x290000000000000ull)); 1075| | } 1076| 322| else { 1077| 322| digit = static_cast((uint32_t(dec_exp) * div100_sig) >> div100_exp); 1078| 322| } 1079| 322| *buffer = static_cast('0' + digit); 1080| 322| hundreds_written = unsigned(dec_exp >= 100); 1081| 322| buffer += hundreds_written; 1082| 322| dec_exp -= digit * 100; 1083| 322| } 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| 322| const char* d2 = digits2(dec_exp); 1087| 322| *buffer = d2[0]; 1088| 322| buffer += hundreds_written | unsigned(dec_exp >= 10); 1089| 322| *buffer = d2[1]; 1090| 322| return buffer + 1; 1091| 678| } _ZN3glz4zmij11detail_impl12float_traitsIdE7to_bitsEd: 358| 988| { 359| 988| sig_type bits; 360| 988| memcpy(&bits, &value, sizeof(value)); 361| 988| return bits; 362| 988| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_expEm: 367| 988| { 368| 988| return static_cast((bits << 1) >> (num_sig_bits + 1)); 369| 988| } _ZN3glz4zmij11detail_impl12float_traitsIdE7get_sigEm: 365| 988| static auto get_sig(sig_type bits) noexcept -> sig_type { return bits & (implicit_bit - 1); } _ZN3glz4zmij11detail_impl12float_traitsIdE11is_negativeEm: 364| 988| static auto is_negative(sig_type bits) noexcept -> bool { return bits >> (num_bits - 1); } _ZN3glz4zmij11detail_impl10to_decimalIdmLb0EEENS1_17to_decimal_resultET0_lbRKNS1_9constantsIXT1_EEE: 868| 678| { 869| 678| using traits = float_traits; 870| 678| int64_t bin_exp = raw_exp - traits::exp_offset; 871| 678| constexpr int num_bits = std::numeric_limits::digits; 872| | 873| 678| constexpr uint64_t log10_2_sig = 78'913; 874| 678| constexpr int32_t log10_2_exp = 18; 875| 678| 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| 678| else { 881| 678| dec_exp = compute_dec_exp(bin_exp); 882| 678| } 883| 678| uint64_t even = 1 - (bin_sig & 1); 884| 678| constexpr int32_t extra_shift = exp_shift_table::extra_shift; 885| | 886| 678| if (!regular) [[unlikely]] { ------------------ | Branch (886:14): [True: 198, False: 480] ------------------ 887| 198| int32_t irregular_dec_exp = compute_dec_exp(bin_exp, false); 888| 198| int32_t shift = compute_exp_shift(bin_exp, irregular_dec_exp + 1) + extra_shift; 889| 198| uint128 pow10 = c.pow10_significands[-irregular_dec_exp - 1]; 890| 198| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 891| | 892| 198| int64_t integral = p.hi >> extra_shift; 893| 198| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 894| | 895| 198| uint64_t half_ulp = pow10.hi >> (extra_shift + 1 - shift); 896| 198| bool round_up = half_ulp > ~uint64_t(0) - fractional; 897| 198| bool round_down = (half_ulp >> 1) > fractional; 898| 198| integral += round_up; 899| | 900| 198| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, (uint64_t(1) << 63) - 1)); 901| 198| int32_t lo = static_cast(umul128_add_hi64(fractional - (half_ulp >> 1), 10, ~uint64_t(0))); 902| 198| if (digit < lo) digit = lo; ------------------ | Branch (902:17): [True: 187, False: 11] ------------------ 903| 198| return {integral, irregular_dec_exp, digit, (round_up + round_down) == 0}; 904| 198| } 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| 480| else { 928| 480| int32_t shift = exp_shift_table::enable ? exp_shifts_v.data[bin_exp + traits::exp_offset] ------------------ | Branch (928:29): [True: 480, Folded] ------------------ 929| 480| : compute_exp_shift(bin_exp, dec_exp + 1) + extra_shift; 930| 480| ZMIJ_ASM(("" : "+r"(dec_exp))); ------------------ | | 126| 480|#define ZMIJ_ASM(x) asm x ------------------ 931| 480| uint128 pow10 = c.pow10_significands[-dec_exp - 1]; 932| 480| uint128 p = umul192_hi128(pow10.hi, pow10.lo, bin_sig << shift); 933| 480| int64_t integral = p.hi >> extra_shift; 934| 480| uint64_t fractional = p.hi << (64 - extra_shift) | p.lo >> extra_shift; 935| 480| uint64_t half_ulp = (pow10.hi >> (extra_shift + 1 - shift)) + even; 936| 480| bool round_up = fractional + half_ulp < fractional; 937| 480| bool round_down = half_ulp > fractional; 938| 480| integral += round_up; 939| | 940| 480| int32_t digit = static_cast(umul128_add_hi64(fractional, 10, c.biased_half)); 941| 480| if (fractional == (1ull << 62)) [[unlikely]] { ------------------ | Branch (941:17): [True: 3, False: 477] ------------------ 942| 3| digit = 2; 943| 3| } 944| 480| return {integral, dec_exp, digit, (round_up + round_down) == 0}; 945| 480| } 946| 480| } _ZN3glz4zmij11detail_impl15compute_dec_expElb: 333| 876| { 334| 876| assert(bin_exp >= -1334 && bin_exp <= 2620); ------------------ | Branch (334:10): [True: 876, False: 0] | Branch (334:10): [True: 876, False: 0] | Branch (334:10): [True: 876, False: 0] ------------------ 335| 876| constexpr int log10_3_over_4_sig = 131'072; 336| 876| constexpr int log10_2_sig = 315'653, log10_2_exp = 20; 337| 876| return static_cast((bin_exp * log10_2_sig - !regular * log10_3_over_4_sig) >> log10_2_exp); 338| 876| } _ZN3glz4zmij11detail_impl17compute_exp_shiftEli: 457| 198| { 458| 198| assert(dec_exp >= -350 && dec_exp <= 350); ------------------ | Branch (458:10): [True: 198, False: 0] | Branch (458:10): [True: 198, False: 0] | Branch (458:10): [True: 198, False: 0] ------------------ 459| 198| constexpr int log2_pow10_sig = 217'707, log2_pow10_exp = 16; 460| 198| int pow10_bin_exp = -dec_exp * log2_pow10_sig >> log2_pow10_exp; 461| 198| return static_cast(bin_exp + pow10_bin_exp + 1); 462| 198| } _ZNK3glz4zmij11detail_impl23pow10_significand_tableILb0EEixEi: 440| 678| { 441| 678| constexpr int dec_exp_min = -293; 442| 678| int i = dec_exp - dec_exp_min; 443| 678| if (compress) return compute(i); ------------------ | Branch (443:17): [Folded, False: 678] ------------------ 444| 678| if (!split_tables) return {data[i * 2], data[i * 2 + 1]}; ------------------ | Branch (444:17): [True: 678, 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| 678| } _ZN3glz4zmij11detail_impl13umul192_hi128Emmm: 308| 678| { 309| 678| uint128_t p = umul128(x_hi, y); 310| 678| uint64_t lo = uint64_t(p) + uint64_t(umul128(x_lo, y) >> 64); 311| 678| return {uint64_t(p >> 64) + (lo < uint64_t(p)), lo}; 312| 678| } _ZN3glz4zmij11detail_impl7umul128Emm: 265| 1.52k| { 266| 1.52k|#if ZMIJ_USE_INT128 267| 1.52k| 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| 1.52k| } _ZN3glz4zmij11detail_impl16umul128_add_hi64Emmm: 298| 876| { 299| 876|#if ZMIJ_USE_INT128 300| 876| 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| 876| } _ZN3glz4zmij11detail_impl5div10Em: 326| 169| { 327| 169| assert(x <= (1ull << 62)); ------------------ | Branch (327:10): [True: 169, False: 0] ------------------ 328| 169| constexpr uint64_t div10_sig64 = (1ull << 63) / 5 + 1; 329| 169| return ZMIJ_USE_INT128 ? umul128_hi64(x, div10_sig64) : x / 10; ------------------ | | 247| 169|#define ZMIJ_USE_INT128 1 | | ------------------ | | | Branch (247:25): [True: 169, Folded] | | ------------------ ------------------ 330| 169| } _ZN3glz4zmij11detail_impl12umul128_hi64Emm: 295| 169| 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| 678| { 810| | if constexpr (num_bits == 32) { 811| | auto result = to_bcd8(value); 812| | return {result.bcd + zeros_v, result.len}; 813| | } 814| 678| 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| 678| uint32_t abbccddee = uint32_t(value / 100'000'000); 834| 678| uint32_t ffgghhii = uint32_t(value % 100'000'000); 835| | 836| 678| const __m128i zeros = _mm_load_si128(m128ptr(&c.zeros)); 837| 678| 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| 678| auto bcd = _mm_shuffle_epi32(unshuffled_bcd, _MM_SHUFFLE(0, 1, 2, 3)); 843| 678|#endif 844| | 845| 678| __m128i mask128 = _mm_cmpgt_epi8(bcd, _mm_setzero_si128()); 846| 678| 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| 678| int len = 63 - clz((mask << 1) | 1); 851| 678|#endif 852| 678| return {_mm_or_si128(bcd, zeros), len}; 853| 678|#endif 854| 678| } 855| 678| } _ZN3glz4zmij11detail_impl20to_unshuffled_digitsILb0EEEDv2_xjjRKNS1_9constantsIXT_EEE: 735| 678| { 736| 678| const __m128i div10k = _mm_load_si128(m128ptr(&c.div10k)); 737| 678| const __m128i neg10k = _mm_load_si128(m128ptr(&c.neg10k)); 738| 678| __m128i x = _mm_set_epi64x(bbccddee, ffgghhii); 739| 678| __m128i y = _mm_add_epi64(x, _mm_mul_epu32(neg10k, _mm_srli_epi64(_mm_mul_epu32(x, div10k), div10k_exp))); 740| 678| return to_bcd_4x4(y, c); 741| 678| } _ZN3glz4zmij11detail_impl10to_bcd_4x4ILb0EEEDv2_xS3_RKNS1_9constantsIXT_EEE: 712| 678| { 713| 678| const __m128i div100 = _mm_load_si128(m128ptr(&c.div100)); 714| 678| 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| 678| const __m128i hundred = _mm_load_si128(m128ptr(&c.hundred)); 723| 678| const __m128i moddiv10 = _mm_load_si128(m128ptr(&c.moddiv10)); 724| | 725| 678| __m128i y_div_100 = _mm_srli_epi16(_mm_mulhi_epu16(y, div100), 3); 726| 678| __m128i y_mod_100 = _mm_sub_epi16(y, _mm_mullo_epi16(y_div_100, hundred)); 727| 678| __m128i z = _mm_or_si128(_mm_slli_epi32(y_mod_100, 16), y_div_100); 728| 678| return _mm_sub_epi16(_mm_slli_epi16(z, 8), _mm_mullo_epi16(moddiv10, _mm_mulhi_epu16(z, div10))); 729| 678|#endif 730| 678| } _ZN3glz4zmij11detail_impl3clzEm: 187| 678| { 188| 678| assert(x != 0); ------------------ | Branch (188:10): [True: 678, False: 0] ------------------ 189| 678|#if ZMIJ_HAS_BUILTIN(__builtin_clzll) 190| 678| 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| 678| } _ZNK3glz4zmij11detail_impl20dec_exp_format_table3getINS1_12float_traitsIdEEEERKNS2_5entryEi: 559| 356| { 560| 356| constexpr auto min = traits::min_fixed_dec_exp, max = Traits::max_fixed_dec_exp; 561| 356| unsigned i = unsigned(dec_exp - min); 562| 356| return data[i <= unsigned(max - min) ? i : num_entries - 1]; ------------------ | Branch (562:25): [True: 356, False: 0] ------------------ 563| 356| }